Index: /trunk/data/gpx-drawing-extensions-1.0.xsd =================================================================== --- /trunk/data/gpx-drawing-extensions-1.0.xsd (revision 15496) +++ /trunk/data/gpx-drawing-extensions-1.0.xsd (revision 15496) @@ -0,0 +1,103 @@ + + + + + + This schema defines drawing extensions for the GPX 1.1 schema (http://www.topografix.com/GPX/1/1/gpx.xsd). + Elements in this schema should be used as child elements of the "extensions" element defined by the GPX schema. + + + + + + + + + The color of the element, i.e. #RRGGBB or #RRGGBBAA. + Note that applications should apply possible alpha values to the lines and opacity to the whole track. This means that overlapping parts of the + track with alpha values will look more intense than individual lines, whereas the opacity affects the whole track including overlapping parts. + + + + + + + + The opacity of the element between 0.00 and 1.00. + + + + + + + + The width of the line in pixels, applications may use a width relative to this value if required. + + + + + + + + The dash pattern of the line, see gpxd:dashPattern_type. Should always be relative to the width. + + + + + + + + + + The hexColor_type must be a # followed by a 6 or 8-digit hex representation of the color (with or without the alpha value). + + + + + + + + + + + + The opacity_type must be a decimal value between 0 and 1. + + + + + + + + + + + + The dashPattern_type can be + - a representation of the pattern as y-n-y-n-... with y being the relative length of the line that is + visible and n being the relative length of the line that is hidden to create a dashed / dotted line. + Has to have an even number of segments (at least two) and can contain multi-digit numbers. + - one of the following predefined values: + none, dash-long, dash-medium, dash-short, dot-sparse, dot-normal, dot-dense, dash-dot, dash-dot-dot + + + + + + + + + + + + + + + + Index: /trunk/data/gpx-extensions-1.1.xsd =================================================================== --- /trunk/data/gpx-extensions-1.1.xsd (revision 15496) +++ /trunk/data/gpx-extensions-1.1.xsd (revision 15496) @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + The layerPreferences contain the preferences that can be set for the layer, e.g. in the "Customize track drawing" dialog in JOSM. + + + + + + + + + + + + + + + + Index: /trunk/data/validator/deprecated.mapcss =================================================================== --- /trunk/data/validator/deprecated.mapcss (revision 15495) +++ /trunk/data/validator/deprecated.mapcss (revision 15496) @@ -662,6 +662,7 @@ assertMatch: "way roof:color=red roof:colour=green"; } - /* further more universal checks, no autofix */ -*[/:color/][!building:color][!roof:color] { +/* further more universal checks, no autofix */ +/* gpxd:color has another warning in unnecessary.mapcss */ +*[/:color/][!building:color][!roof:color][!gpxd:color] { throwWarning: tr("{0} is deprecated", "{0.key}"); suggestAlternative: ":colour"; Index: /trunk/data/validator/unnecessary.mapcss =================================================================== --- /trunk/data/validator/unnecessary.mapcss (revision 15495) +++ /trunk/data/validator/unnecessary.mapcss (revision 15496) @@ -168,9 +168,10 @@ /* #2760 */ -*[/^gpx:/] { +*[/^(gpx|gpxx|gpxd):/] { throwWarning: tr("{0} should not be uploaded", "{0.key}"); group: tr("unnecessary tag"); fixRemove: "{0.key}"; assertMatch: "node gpx:time=2018-01-01T12:00:00Z"; + assertMatch: "node gpxd:color=#FF0000"; assertNoMatch: "node source=gpx:foo"; } Index: /trunk/src/org/openstreetmap/josm/actions/SaveAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/actions/SaveAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/actions/SaveAction.java (revision 15496) @@ -5,8 +5,15 @@ import static org.openstreetmap.josm.tools.I18n.tr; +import java.awt.GridBagLayout; import java.awt.event.KeyEvent; import java.beans.PropertyChangeListener; import java.io.File; +import javax.swing.JCheckBox; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.SwingConstants; + +import org.openstreetmap.josm.data.gpx.GpxData.GpxDataChangeListener; import org.openstreetmap.josm.gui.ExtendedDialog; import org.openstreetmap.josm.gui.MainApplication; @@ -17,4 +24,7 @@ import org.openstreetmap.josm.gui.layer.OsmDataLayer; import org.openstreetmap.josm.gui.layer.SaveToFile; +import org.openstreetmap.josm.gui.util.GuiHelper; +import org.openstreetmap.josm.spi.preferences.Config; +import org.openstreetmap.josm.tools.GBC; import org.openstreetmap.josm.tools.Shortcut; @@ -33,4 +43,6 @@ }; + private final GpxDataChangeListener updateOnRequireSaveChangeGpx = evt -> updateEnabledState(); + /** * Construct the action with "Save" as label. @@ -38,5 +50,6 @@ private SaveAction() { super(tr("Save"), "save", tr("Save the current data."), - Shortcut.registerShortcut("system:save", tr("File: {0}", tr("Save")), KeyEvent.VK_S, Shortcut.CTRL)); + Shortcut.registerShortcut("system:save", tr("File: {0}", tr("Save")), KeyEvent.VK_S, Shortcut.CTRL), + true); setHelpId(ht("/Action/Save")); } @@ -55,6 +68,10 @@ @Override public void layerAdded(LayerAddEvent e) { - if (e.getAddedLayer() instanceof OsmDataLayer) { - e.getAddedLayer().addPropertyChangeListener(updateOnRequireSaveChange); + Layer l = e.getAddedLayer(); + if (l instanceof OsmDataLayer) { + l.addPropertyChangeListener(updateOnRequireSaveChange); + } + if (l instanceof GpxLayer) { + ((GpxLayer) l).data.addWeakChangeListener(updateOnRequireSaveChangeGpx); } super.layerAdded(e); @@ -63,6 +80,10 @@ @Override public void layerRemoving(LayerRemoveEvent e) { - if (e.getRemovedLayer() instanceof OsmDataLayer) { - e.getRemovedLayer().removePropertyChangeListener(updateOnRequireSaveChange); + Layer l = e.getRemovedLayer(); + if (l instanceof OsmDataLayer) { + l.removePropertyChangeListener(updateOnRequireSaveChange); + } + if (l instanceof GpxLayer) { + ((GpxLayer) l).data.removeChangeListener(updateOnRequireSaveChangeGpx); } super.layerRemoving(e); @@ -74,7 +95,8 @@ protected void updateEnabledState() { Layer activeLayer = getLayerManager().getActiveLayer(); - setEnabled(activeLayer != null && activeLayer.isSavable() - && (!(activeLayer.getAssociatedFile() != null - && activeLayer instanceof SaveToFile && !((SaveToFile) activeLayer).requiresSaveToFile()))); + boolean en = activeLayer != null + && activeLayer.isSavable() && (!(activeLayer.getAssociatedFile() != null + && activeLayer instanceof SaveToFile && !((SaveToFile) activeLayer).requiresSaveToFile())); + GuiHelper.runInEDT(() -> setEnabled(en)); } @@ -86,7 +108,13 @@ } - // Ask for overwrite in case of GpxLayer: GpxLayers usually are imports - // and modifying is an error most of the time. - if (f != null && layer instanceof GpxLayer) { + // Ask for overwrite in case of GpxLayer + if (f != null && layer instanceof GpxLayer && !Config.getPref().getBoolean("gpx.export.overwrite", false)) { + JPanel p = new JPanel(new GridBagLayout()); + JLabel label = new JLabel(tr("File {0} exists. Overwrite?", f.getName())); + label.setHorizontalAlignment(SwingConstants.CENTER); + JCheckBox remember = new JCheckBox(tr("Remember choice")); + remember.setHorizontalAlignment(SwingConstants.CENTER); + p.add(label, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 5, 5, 10)); + p.add(remember, GBC.eop().fill(GBC.HORIZONTAL)); ExtendedDialog dialog = new ExtendedDialog( MainApplication.getMainFrame(), @@ -94,7 +122,9 @@ tr("Overwrite"), tr("Cancel")) .setButtonIcons("save_as", "cancel") - .setContent(tr("File {0} exists. Overwrite?", f.getName())); + .setContent(p); if (dialog.showDialog().getValue() != 1) { f = null; + } else if (remember.isSelected()) { + Config.getPref().putBoolean("gpx.export.overwrite", true); } } Index: /trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java =================================================================== --- /trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java (revision 15496) @@ -20,7 +20,6 @@ import org.openstreetmap.josm.gui.MainApplication; import org.openstreetmap.josm.gui.io.importexport.FileExporter; +import org.openstreetmap.josm.gui.layer.AbstractModifiableLayer; import org.openstreetmap.josm.gui.layer.Layer; -import org.openstreetmap.josm.gui.layer.OsmDataLayer; -import org.openstreetmap.josm.gui.layer.SaveToFile; import org.openstreetmap.josm.gui.util.GuiHelper; import org.openstreetmap.josm.gui.widgets.AbstractFileChooser; @@ -36,4 +35,6 @@ public abstract class SaveActionBase extends DiskAccessAction { + private boolean quiet; + /** * Constructs a new {@code SaveActionBase}. @@ -47,9 +48,23 @@ } + /** + * Constructs a new {@code SaveActionBase}. + * @param name The action's text as displayed on the menu (if it is added to a menu) + * @param iconName The filename of the icon to use + * @param tooltip A longer description of the action that will be displayed in the tooltip + * @param shortcut A ready-created shortcut object or {@code null} if you don't want a shortcut + * @param quiet whether the quiet exporter is called + * @since 15496 + */ + public SaveActionBase(String name, String iconName, String tooltip, Shortcut shortcut, boolean quiet) { + super(name, iconName, tooltip, shortcut); + this.quiet = quiet; + } + @Override public void actionPerformed(ActionEvent e) { if (!isEnabled()) return; - doSave(); + doSave(quiet); } @@ -59,7 +74,17 @@ */ public boolean doSave() { + return doSave(false); + } + + /** + * Saves the active layer. + * @param quiet If the file is saved without prompting the user + * @return {@code true} if the save operation succeeds + * @since 15496 + */ + public boolean doSave(boolean quiet) { Layer layer = getLayerManager().getActiveLayer(); if (layer != null && layer.isSavable()) { - return doSave(layer); + return doSave(layer, quiet); } return false; @@ -72,11 +97,19 @@ */ public boolean doSave(Layer layer) { + return doSave(layer, false); + } + + /** + * Saves the given layer. + * @param layer layer to save + * @param quiet If the file is saved without prompting the user + * @return {@code true} if the save operation succeeds + * @since 15496 + */ + public boolean doSave(Layer layer, boolean quiet) { if (!layer.checkSaveConditions()) return false; - final boolean requiresSave = layer instanceof SaveToFile && ((SaveToFile) layer).requiresSaveToFile(); - final boolean result = doInternalSave(layer, getFile(layer)); - if (!requiresSave) { - updateEnabledState(); - } + final boolean result = doInternalSave(layer, getFile(layer), quiet); + updateEnabledState(); return result; } @@ -87,6 +120,5 @@ * @param file The destination file * @param checkSaveConditions if {@code true}, checks preconditions before saving. Set it to {@code false} to skip it - * if preconditions have already been checked (as this check can prompt UI dialog in EDT it may be best in some cases - * to do it earlier). + * and prevent dialogs from being shown. * @return {@code true} if the layer has been successfully saved, {@code false} otherwise * @since 7204 @@ -95,8 +127,8 @@ if (checkSaveConditions && !layer.checkSaveConditions()) return false; - return doInternalSave(layer, file); - } - - private static boolean doInternalSave(Layer layer, File file) { + return doInternalSave(layer, file, !checkSaveConditions); + } + + private static boolean doInternalSave(Layer layer, File file, boolean quiet) { if (file == null) return false; @@ -107,5 +139,9 @@ for (FileExporter exporter : ExtensionFileFilter.getExporters()) { if (exporter.acceptFile(file, layer)) { - exporter.exportData(file, layer); + if (quiet) { + exporter.exportDataQuiet(file, layer); + } else { + exporter.exportData(file, layer); + } exported = true; canceled = exporter.isCanceled(); @@ -125,6 +161,6 @@ } layer.setAssociatedFile(file); - if (layer instanceof OsmDataLayer) { - ((OsmDataLayer) layer).onPostSaveToFile(); + if (layer instanceof AbstractModifiableLayer) { + ((AbstractModifiableLayer) layer).onPostSaveToFile(); } } catch (IOException | InvalidPathException e) { Index: /trunk/src/org/openstreetmap/josm/actions/SaveAsAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/actions/SaveAsAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/actions/SaveAsAction.java (revision 15496) @@ -25,5 +25,5 @@ super(tr("Save As..."), "save_as", tr("Save the current data to a new file."), Shortcut.registerShortcut("system:saveas", tr("File: {0}", tr("Save As...")), - KeyEvent.VK_S, Shortcut.CTRL_SHIFT)); + KeyEvent.VK_S, Shortcut.CTRL_SHIFT), false); setHelpId(ht("/Action/SaveAs")); } Index: /trunk/src/org/openstreetmap/josm/actions/ShowStatusReportAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/actions/ShowStatusReportAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/actions/ShowStatusReportAction.java (revision 15496) @@ -294,6 +294,5 @@ Preferences.main().getAllSettings().forEach((key, setting) -> { - if (key.startsWith("marker.show") - || "file-open.history".equals(key) + if ("file-open.history".equals(key) || "download.overpass.query".equals(key) || "download.overpass.queries".equals(key) Index: /trunk/src/org/openstreetmap/josm/actions/relation/ExportRelationToGpxAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/actions/relation/ExportRelationToGpxAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/actions/relation/ExportRelationToGpxAction.java (revision 15496) @@ -26,5 +26,5 @@ import org.openstreetmap.josm.actions.IPrimitiveAction; import org.openstreetmap.josm.data.gpx.GpxData; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.IPrimitive; @@ -155,5 +155,5 @@ if (!wayConnectionType.isOnewayLoopBackwardPart && !wayConnectionType.direction.isRoundabout()) { if (!wayConnectionType.linkPrev && !trkseg.isEmpty()) { - gpxData.addTrack(new ImmutableGpxTrack(trk, trkAttr)); + gpxData.addTrack(new GpxTrack(trk, trkAttr)); trkAttr.clear(); trk.clear(); @@ -180,5 +180,5 @@ } } - gpxData.addTrack(new ImmutableGpxTrack(trk, trkAttr)); + gpxData.addTrack(new GpxTrack(trk, trkAttr)); String lprefix = relations.iterator().next().getName(); Index: /trunk/src/org/openstreetmap/josm/data/Preferences.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/Preferences.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/Preferences.java (revision 15496) @@ -22,4 +22,5 @@ import java.util.HashSet; import java.util.Iterator; +import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -30,4 +31,5 @@ import java.util.concurrent.TimeUnit; import java.util.function.Predicate; +import java.util.stream.Collectors; import java.util.stream.Stream; @@ -82,4 +84,5 @@ public class Preferences extends AbstractPreferences { + /** remove if key equals */ private static final String[] OBSOLETE_PREF_KEYS = { "remotecontrol.https.enabled", /* remove entry after Dec. 2019 */ @@ -87,7 +90,78 @@ }; + /** remove if key starts with */ + private static final String[] OBSOLETE_PREF_KEYS_START = { + //only remove layer specific prefs + "draw.rawgps.layer.wpt.", + "draw.rawgps.layer.audiowpt.", + "draw.rawgps.lines.force.", + "draw.rawgps.lines.alpha-blend.", + "draw.rawgps.lines.", + "markers.show ", //uses space as separator + "marker.makeautomarker.", + "clr.layer.", + + //remove both layer specific and global prefs + "draw.rawgps.colors", + "draw.rawgps.direction", + "draw.rawgps.alternatedirection", + "draw.rawgps.linewidth", + "draw.rawgps.max-line-length.local", + "draw.rawgps.max-line-length", + "draw.rawgps.large", + "draw.rawgps.large.size", + "draw.rawgps.hdopcircle", + "draw.rawgps.min-arrow-distance", + "draw.rawgps.colorTracksTune", + "draw.rawgps.colors.dynamic", + "draw.rawgps.lines.local", + "draw.rawgps.heatmap" + }; + + /** keep subkey even if it starts with any of {@link #OBSOLETE_PREF_KEYS_START} */ + private static final List KEEP_PREF_KEYS = Arrays.asList( + "draw.rawgps.lines.alpha-blend", + "draw.rawgps.lines.arrows", + "draw.rawgps.lines.arrows.fast", + "draw.rawgps.lines.arrows.min-distance", + "draw.rawgps.lines.force", + "draw.rawgps.lines.max-length", + "draw.rawgps.lines.max-length.local", + "draw.rawgps.lines.width" + ); + + /** rename keys that equal */ + private final static Map UPDATE_PREF_KEYS = getUpdatePrefKeys(); + + private static Map getUpdatePrefKeys() { + HashMap m = new HashMap<>(); + m.put("draw.rawgps.direction", "draw.rawgps.lines.arrows"); + m.put("draw.rawgps.alternatedirection", "draw.rawgps.lines.arrows.fast"); + m.put("draw.rawgps.min-arrow-distance", "draw.rawgps.lines.arrows.min-distance"); + m.put("draw.rawgps.linewidth", "draw.rawgps.lines.width"); + m.put("draw.rawgps.max-line-length.local", "draw.rawgps.lines.max-length.local"); + m.put("draw.rawgps.max-line-length", "draw.rawgps.lines.max-length"); + m.put("draw.rawgps.large", "draw.rawgps.points.large"); + m.put("draw.rawgps.large.alpha", "draw.rawgps.points.large.alpha"); + m.put("draw.rawgps.large.size", "draw.rawgps.points.large.size"); + m.put("draw.rawgps.hdopcircle", "draw.rawgps.points.hdopcircle"); + m.put("draw.rawgps.layer.wpt.pattern", "draw.rawgps.markers.pattern"); + m.put("draw.rawgps.layer.audiowpt.pattern", "draw.rawgps.markers.audio.pattern"); + m.put("draw.rawgps.colors", "draw.rawgps.colormode"); + m.put("draw.rawgps.colorTracksTune", "draw.rawgps.colormode.velocity.tune"); + m.put("draw.rawgps.colors.dynamic", "draw.rawgps.colormode.dynamic-range"); + m.put("draw.rawgps.heatmap.line-extra", "draw.rawgps.colormode.heatmap.line-extra"); + m.put("draw.rawgps.heatmap.colormap", "draw.rawgps.colormode.heatmap.colormap"); + m.put("draw.rawgps.heatmap.use-points", "draw.rawgps.colormode.heatmap.use-points"); + m.put("draw.rawgps.heatmap.gain", "draw.rawgps.colormode.heatmap.gain"); + m.put("draw.rawgps.heatmap.lower-limit", "draw.rawgps.colormode.heatmap.lower-limit"); + m.put("draw.rawgps.date-coloring-min-dt", "draw.rawgps.colormode.time.min-distance"); + return Collections.unmodifiableMap(m); + } + private static final long MAX_AGE_DEFAULT_PREFERENCES = TimeUnit.DAYS.toSeconds(50); private final IBaseDirectories dirs; + boolean modifiedDefault; /** @@ -416,5 +490,5 @@ settingsMap.clear(); settingsMap.putAll(reader.getSettings()); - removeObsolete(reader.getVersion()); + removeAndUpdateObsolete(reader.getVersion()); } @@ -521,4 +595,17 @@ return; } + File def = getDefaultsCacheFile(); + if (def.exists()) { + try { + loadDefaults(); + } catch (IOException | XMLStreamException | SAXException e) { + Logging.error(e); + Logging.warn(tr("Failed to load defaults cache file: {0}", def)); + defaultsMap.clear(); + if (!def.delete()) { + Logging.warn(tr("Failed to delete faulty defaults cache file: {0}", def)); + } + } + } try { load(); @@ -544,17 +631,4 @@ Logging.error(e1); Logging.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile())); - } - } - File def = getDefaultsCacheFile(); - if (def.exists()) { - try { - loadDefaults(); - } catch (IOException | XMLStreamException | SAXException e) { - Logging.error(e); - Logging.warn(tr("Failed to load defaults cache file: {0}", def)); - defaultsMap.clear(); - if (!def.delete()) { - Logging.warn(tr("Failed to delete faulty defaults cache file: {0}", def)); - } } } @@ -756,16 +830,64 @@ /** - * Removes obsolete preference settings. If you throw out a once-used preference + * Removes and updates obsolete preference settings. If you throw out a once-used preference * setting, add it to the list here with an expiry date (written as comment). If you * see something with an expiry date in the past, remove it from the list. * @param loadedVersion JOSM version when the preferences file was written */ - private void removeObsolete(int loadedVersion) { + private void removeAndUpdateObsolete(int loadedVersion) { + Logging.trace("Update obsolete preference keys for version {0}", Integer.toString(loadedVersion)); + for (Entry e : UPDATE_PREF_KEYS.entrySet()) { + String oldkey = e.getKey(); + String newkey = e.getValue(); + if (settingsMap.containsKey(oldkey)) { + Setting value = settingsMap.remove(oldkey); + settingsMap.putIfAbsent(newkey, value); + Logging.info(tr("Updated preference setting {0} to {1}", oldkey, newkey)); + } + } + Logging.trace("Remove obsolete preferences for version {0}", Integer.toString(loadedVersion)); for (String key : OBSOLETE_PREF_KEYS) { if (settingsMap.containsKey(key)) { settingsMap.remove(key); - Logging.info(tr("Preference setting {0} has been removed since it is no longer used.", key)); - } + Logging.info(tr("Removed preference setting {0} since it is no longer used", key)); + } + if (defaultsMap.containsKey(key)) { + defaultsMap.remove(key); + Logging.info(tr("Removed preference default {0} since it is no longer used", key)); + modifiedDefault = true; + } + } + for (String key : OBSOLETE_PREF_KEYS_START) { + settingsMap.entrySet().stream() + .filter(e -> e.getKey().startsWith(key)) + .collect(Collectors.toSet()) + .forEach(e -> { + String k = e.getKey(); + if (!KEEP_PREF_KEYS.contains(k)) { + settingsMap.remove(k); + Logging.info(tr("Removed preference setting {0} since it is no longer used", k)); + } + }); + defaultsMap.entrySet().stream() + .filter(e -> e.getKey().startsWith(key)) + .collect(Collectors.toSet()) + .forEach(e -> { + String k = e.getKey(); + if (!KEEP_PREF_KEYS.contains(k)) { + defaultsMap.remove(k); + Logging.info(tr("Removed preference default {0} since it is no longer used", k)); + modifiedDefault = true; + } + }); + } + if (modifiedDefault) { + try { + saveDefaults(); + Logging.info(tr("Saved updated default preferences.")); + } catch (IOException ex) { + Logging.log(Logging.LEVEL_WARN, tr("Failed to save default preferences."), ex); + } + modifiedDefault = false; } } Index: unk/src/org/openstreetmap/josm/data/gpx/Extensions.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/Extensions.java (revision 15495) +++ (revision ) @@ -1,19 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.data.gpx; - -import java.util.LinkedHashMap; - -/** - * Data class for extensions in a GPX-File. - */ -public class Extensions extends LinkedHashMap { - - private static final long serialVersionUID = 1L; - - /** - * Constructs a new {@code Extensions}. - */ - public Extensions() { - super(); - } -} Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxConstants.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxConstants.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxConstants.java (revision 15496) @@ -2,8 +2,11 @@ package org.openstreetmap.josm.data.gpx; +import java.awt.Color; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; +import java.util.Map; +import java.util.TreeMap; import org.openstreetmap.josm.data.Bounds; @@ -96,15 +99,36 @@ */ String META_BOUNDS = META_PREFIX + "bounds"; - /** - * A constant for the metadata hash map: the extension data. This is a {@link Extensions} object - * @see GpxData#addExtension(String, String) - * @see GpxData#get(String) - */ - String META_EXTENSIONS = META_PREFIX + "extensions"; - - /** - * A namespace for josm GPX extensions - */ - String JOSM_EXTENSIONS_NAMESPACE_URI = Config.getUrls().getXMLBase() + "/gpx-extensions-1.0"; + + /** + * Namespace for the XSD + */ + String XML_URI_XSD = "http://www.w3.org/2001/XMLSchema-instance"; + + /** + * Namespace for JOSM GPX extensions + */ + String XML_URI_EXTENSIONS_JOSM = Config.getUrls().getXMLBase() + "/gpx-extensions-1.1"; + /** + * Location of the XSD schema for JOSM GPX extensions + */ + String XML_XSD_EXTENSIONS_JOSM = Config.getUrls().getXMLBase() + "/gpx-extensions-1.1.xsd"; + + /** + * Namespace for GPX drawing extensions + */ + String XML_URI_EXTENSIONS_DRAWING = Config.getUrls().getXMLBase() + "/gpx-drawing-extensions-1.0"; + /** + * Location of the XSD schema for GPX drawing extensions + */ + String XML_XSD_EXTENSIONS_DRAWING = Config.getUrls().getXMLBase() + "/gpx-drawing-extensions-1.0.xsd"; + + /** + * Namespace for Garmin GPX extensions + */ + String XML_URI_EXTENSIONS_GARMIN = "http://www.garmin.com/xmlschemas/GpxExtensions/v3"; + /** + * Location of the XSD schema for GPX drawing extensions + */ + String XML_XSD_EXTENSIONS_GARMIN = "http://www.garmin.com/xmlschemas/GpxExtensionsv3.xsd"; /** Elevation (in meters) of the point. */ @@ -155,5 +179,5 @@ List WPT_KEYS = Collections.unmodifiableList(Arrays.asList(PT_ELE, PT_TIME, PT_MAGVAR, PT_GEOIDHEIGHT, GPX_NAME, GPX_CMT, GPX_DESC, GPX_SRC, META_LINKS, PT_SYM, PT_TYPE, - PT_FIX, PT_SAT, PT_HDOP, PT_VDOP, PT_PDOP, PT_AGEOFDGPSDATA, PT_DGPSID, META_EXTENSIONS)); + PT_FIX, PT_SAT, PT_HDOP, PT_VDOP, PT_PDOP, PT_AGEOFDGPSDATA, PT_DGPSID)); /** @@ -161,5 +185,62 @@ */ List RTE_TRK_KEYS = Collections.unmodifiableList(Arrays.asList( - GPX_NAME, GPX_CMT, GPX_DESC, GPX_SRC, META_LINKS, "number", PT_TYPE, META_EXTENSIONS)); + GPX_NAME, GPX_CMT, GPX_DESC, GPX_SRC, META_LINKS, "number", PT_TYPE)); + + /** + * Map with all supported Garmin colors + */ + Map GARMIN_COLORS = getGarminColors(); + + /** + * Helper method for {@link #GARMIN_COLORS} + * @return Map with all supported Garmin colors + */ + static Map getGarminColors() { + TreeMap m = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + m.put("Black", Color.BLACK); + m.put("DarkRed", new Color(139, 0, 0)); + m.put("DarkGreen", new Color(0, 100, 0)); + m.put("DarkYellow", new Color(255, 170, 0)); + m.put("DarkBlue", new Color(0, 0, 139)); + m.put("DarkMagenta", new Color(139, 0, 139)); + m.put("DarkCyan", new Color(0, 139, 139)); + m.put("LightGray", Color.LIGHT_GRAY); + m.put("DarkGray", Color.DARK_GRAY); + m.put("Red", Color.RED); + m.put("Green", Color.GREEN); + m.put("Yellow", Color.YELLOW); + m.put("Blue", Color.BLUE); + m.put("Magenta", Color.MAGENTA); + m.put("Cyan", Color.CYAN); + m.put("White", Color.WHITE); + m.put("Transparent", new Color(0, 0, 0, 255)); + return Collections.unmodifiableMap(m); + } + + /** + * Enum with color formats that can be written by JOSM + */ + enum ColorFormat { + /** Drawing extension format */ + GPXD, + /** Garmin track extension format */ + GPXX + } + + /** + * Map with all supported extension abbreviations for easier readability in OSM layers + */ + Map EXTENSION_ABBREVIATIONS = getExtensionAbbreviations(); + + /** + * Helper method for {@link #EXTENSION_ABBREVIATIONS} + * @return Map with all supported extension abbreviations + */ + static Map getExtensionAbbreviations() { + TreeMap m = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + m.put("gpx:extension:gpxx:TrackExtensions:DisplayColor", "gpxx:DisplayColor"); + m.put("gpx:extension:gpxd:color", "gpxd:color"); + return m; + } /** Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java (revision 15496) @@ -16,4 +16,6 @@ import java.util.Map; import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; @@ -24,5 +26,5 @@ import org.openstreetmap.josm.data.DataSource; import org.openstreetmap.josm.data.coor.EastNorth; -import org.openstreetmap.josm.data.gpx.GpxTrack.GpxTrackChangeListener; +import org.openstreetmap.josm.data.gpx.IGpxTrack.GpxTrackChangeListener; import org.openstreetmap.josm.data.projection.ProjectionRegistry; import org.openstreetmap.josm.gui.MainApplication; @@ -41,4 +43,18 @@ /** + * Constructs a new GpxData. + */ + public GpxData() {} + + /** + * Constructs a new GpxData that is currently being initialized, so no listeners will be fired until {@link #endUpdate()} is called. + * @param initializing true + * @since 15496 + */ + public GpxData(boolean initializing) { + this.initializing = initializing; + } + + /** * The disk file this layer is stored in, if it is a local layer. May be null. */ @@ -66,5 +82,17 @@ */ private final ArrayList privateWaypoints = new ArrayList<>(); - private final GpxTrackChangeListener proxy = e -> fireInvalidate(); + /** + * All namespaces read from the original file + */ + private final List namespaces = new ArrayList<>(); + /** + * The layer specific prefs formerly saved in the preferences, e.g. drawing options. + * NOT the track specific settings (e.g. color, width) + */ + private final Map layerPrefs = new HashMap<>(); + + private final GpxTrackChangeListener proxy = e -> invalidate(); + private boolean modified, updating, initializing; + private boolean suppressedInvalidate; /** @@ -72,5 +100,5 @@ * @see #getTracks() */ - public final Collection tracks = new ListeningCollection(privateTracks, this::fireInvalidate) { + public final Collection tracks = new ListeningCollection(privateTracks, this::invalidate) { @Override @@ -91,5 +119,5 @@ * @see #getRoutes() */ - public final Collection routes = new ListeningCollection<>(privateRoutes, this::fireInvalidate); + public final Collection routes = new ListeningCollection<>(privateRoutes, this::invalidate); /** @@ -97,5 +125,5 @@ * @see #getWaypoints() */ - public final Collection waypoints = new ListeningCollection<>(privateWaypoints, this::fireInvalidate); + public final Collection waypoints = new ListeningCollection<>(privateWaypoints, this::invalidate); /** @@ -108,6 +136,4 @@ private final ListenerList listeners = ListenerList.create(); - - static class TimestampConfictException extends Exception {} private List segSpans; @@ -157,11 +183,11 @@ other.privateWaypoints.forEach(this::addWaypoint); dataSources.addAll(other.dataSources); - fireInvalidate(); + invalidate(); } private void cutOverlapping(GpxTrack trk, boolean connect) { - List segsOld = new ArrayList<>(trk.getSegments()); - List segsNew = new ArrayList<>(); - for (GpxTrackSegment seg : segsOld) { + List segsOld = new ArrayList<>(trk.getSegments()); + List segsNew = new ArrayList<>(); + for (IGpxTrackSegment seg : segsOld) { GpxTrackSegmentSpan s = GpxTrackSegmentSpan.tryGetFromSegment(seg); if (s != null && anySegmentOverlapsWith(s)) { @@ -204,8 +230,8 @@ // because other high priority tracks between the same waypoints could follow if (!wpsNew.isEmpty()) { - segsNew.add(new ImmutableGpxTrackSegment(wpsNew)); + segsNew.add(new GpxTrackSegment(wpsNew)); } if (!segsNew.isEmpty()) { - privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes())); + privateTracks.add(new GpxTrack(segsNew, trk.getAttributes())); } segsNew = new ArrayList<>(); @@ -222,8 +248,8 @@ //track has to be split, because we have an overlapping short track in the middle if (!wpsNew.isEmpty()) { - segsNew.add(new ImmutableGpxTrackSegment(wpsNew)); + segsNew.add(new GpxTrackSegment(wpsNew)); } if (!segsNew.isEmpty()) { - privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes())); + privateTracks.add(new GpxTrack(segsNew, trk.getAttributes())); } segsNew = new ArrayList<>(); @@ -239,5 +265,5 @@ } if (!wpsNew.isEmpty()) { - segsNew.add(new ImmutableGpxTrackSegment(wpsNew)); + segsNew.add(new GpxTrackSegment(wpsNew)); } } else { @@ -248,5 +274,5 @@ privateTracks.add(trk); } else if (!segsNew.isEmpty()) { - privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes())); + privateTracks.add(new GpxTrack(segsNew, trk.getAttributes())); } } @@ -254,5 +280,5 @@ private void connectTracks(WayPoint prevWp, GpxTrackSegmentSpan span, Map attr) { if (prevWp != null && !span.lastEquals(prevWp)) { - privateTracks.add(new ImmutableGpxTrack(Arrays.asList(Arrays.asList(new WayPoint(prevWp), span.getFirstWp())), attr)); + privateTracks.add(new GpxTrack(Arrays.asList(Arrays.asList(new WayPoint(prevWp), span.getFirstWp())), attr)); } } @@ -310,5 +336,5 @@ } - static GpxTrackSegmentSpan tryGetFromSegment(GpxTrackSegment seg) { + static GpxTrackSegmentSpan tryGetFromSegment(IGpxTrackSegment seg) { WayPoint b = getNextWpWithTime(seg, true); if (b != null) { @@ -321,5 +347,5 @@ } - private static WayPoint getNextWpWithTime(GpxTrackSegment seg, boolean forward) { + private static WayPoint getNextWpWithTime(IGpxTrackSegment seg, boolean forward) { List wps = new ArrayList<>(seg.getWayPoints()); for (int i = forward ? 0 : wps.size() - 1; i >= 0 && i < wps.size(); i += forward ? 1 : -1) { @@ -341,5 +367,5 @@ segSpans = new ArrayList<>(); for (GpxTrack trk : privateTracks) { - for (GpxTrackSegment seg : trk.getSegments()) { + for (IGpxTrackSegment seg : trk.getSegments()) { GpxTrackSegmentSpan s = GpxTrackSegmentSpan.tryGetFromSegment(seg); if (s != null) { @@ -374,5 +400,5 @@ * @return {@code Stream} */ - private synchronized Stream getTrackSegmentsStream() { + public synchronized Stream getTrackSegmentsStream() { return getTracks().stream().flatMap(trk -> trk.getSegments().stream()); } @@ -398,5 +424,5 @@ privateTracks.add(track); track.addListener(proxy); - fireInvalidate(); + invalidate(); } @@ -411,5 +437,5 @@ } track.removeListener(proxy); - fireInvalidate(); + invalidate(); } @@ -421,6 +447,6 @@ */ public synchronized void combineTracksToSegmentedTrack() { - List segs = getTrackSegmentsStream() - .collect(Collectors.toCollection(ArrayList::new)); + List segs = getTrackSegmentsStream() + .collect(Collectors.toCollection(ArrayList::new)); Map attrs = new HashMap<>(privateTracks.get(0).getAttributes()); @@ -432,5 +458,5 @@ clearTracks(); - addTrack(new ImmutableGpxTrack(segs, attrs)); + addTrack(new GpxTrack(segs, attrs)); } @@ -468,5 +494,5 @@ HashMap attrs = new HashMap<>(trk.getAttributes()); ensureUniqueName(attrs, counts, srcLayerName); - return new ImmutableGpxTrack(Arrays.asList(seg), attrs); + return new GpxTrack(Arrays.asList(seg), attrs); })) .collect(Collectors.toCollection(ArrayList::new)); @@ -539,5 +565,5 @@ } privateRoutes.add(route); - fireInvalidate(); + invalidate(); } @@ -551,5 +577,5 @@ throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", route)); } - fireInvalidate(); + invalidate(); } @@ -573,5 +599,5 @@ } privateWaypoints.add(waypoint); - fireInvalidate(); + invalidate(); } @@ -585,5 +611,5 @@ throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", waypoint)); } - fireInvalidate(); + invalidate(); } @@ -601,5 +627,5 @@ * @see #getTracks() * @see GpxTrack#getSegments() - * @see GpxTrackSegment#getWayPoints() + * @see IGpxTrackSegment#getWayPoints() * @since 12156 */ @@ -768,5 +794,5 @@ double rx = 0.0, ry = 0.0, sx, sy, x, y; for (GpxTrack track : privateTracks) { - for (GpxTrackSegment seg : track.getSegments()) { + for (IGpxTrackSegment seg : track.getSegments()) { WayPoint r = null; for (WayPoint wpSeg : seg.getWayPoints()) { @@ -883,5 +909,5 @@ private Iterator itTracks; private int idxTracks; - private Iterator itTrackSegments; + private Iterator itTrackSegments; private final Iterator itRoutes; @@ -889,4 +915,5 @@ private final boolean[] trackVisibility; private Map trackAttributes; + private GpxTrack curTrack; /** @@ -922,15 +949,15 @@ if (itTracks != null) { if (itTrackSegments != null && itTrackSegments.hasNext()) { - return new Line(itTrackSegments.next(), trackAttributes); + return new Line(itTrackSegments.next(), trackAttributes, curTrack.getColor()); } else { while (itTracks.hasNext()) { - GpxTrack nxtTrack = itTracks.next(); - trackAttributes = nxtTrack.getAttributes(); + curTrack = itTracks.next(); + trackAttributes = curTrack.getAttributes(); idxTracks++; if (trackVisibility != null && !trackVisibility[idxTracks]) continue; - itTrackSegments = nxtTrack.getSegments().iterator(); + itTrackSegments = curTrack.getSegments().iterator(); if (itTrackSegments.hasNext()) { - return new Line(itTrackSegments.next(), trackAttributes); + return new Line(itTrackSegments.next(), trackAttributes, curTrack.getColor()); } } @@ -957,8 +984,29 @@ } + /** + * The layer specific prefs formerly saved in the preferences, e.g. drawing options. + * NOT the track specific settings (e.g. color, width) + * @return Modifiable map + * @since 15496 + */ + public Map getLayerPrefs() { + return layerPrefs; + } + + /** + * All XML namespaces read from the original file + * @return Modifiable list + * @since 15496 + */ + public List getNamespaces() { + return namespaces; + } + @Override public synchronized int hashCode() { final int prime = 31; - int result = 1; + int result = prime + super.hashCode(); + result = prime * result + ((namespaces == null) ? 0 : namespaces.hashCode()); + result = prime * result + ((layerPrefs == null) ? 0 : layerPrefs.hashCode()); result = prime * result + ((dataSources == null) ? 0 : dataSources.hashCode()); result = prime * result + ((privateRoutes == null) ? 0 : privateRoutes.hashCode()); @@ -973,4 +1021,6 @@ return true; if (obj == null) + return false; + if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) @@ -981,4 +1031,9 @@ return false; } else if (!dataSources.equals(other.dataSources)) + return false; + if (layerPrefs == null) { + if (other.layerPrefs != null) + return false; + } else if (!layerPrefs.equals(other.layerPrefs)) return false; if (privateRoutes == null) { @@ -997,5 +1052,16 @@ } else if (!privateWaypoints.equals(other.privateWaypoints)) return false; + if (namespaces == null) { + if (other.namespaces != null) + return false; + } else if (!namespaces.equals(other.namespaces)) + return false; return true; + } + + @Override + public void put(String key, Object value) { + super.put(key, value); + invalidate(); } @@ -1026,8 +1092,43 @@ } - private void fireInvalidate() { - if (listeners.hasListeners()) { - GpxDataChangeEvent e = new GpxDataChangeEvent(this); - listeners.fireEvent(l -> l.gpxDataChanged(e)); + /** + * Fires event listeners and sets the modified flag to true. + */ + public void invalidate() { + fireInvalidate(true); + } + + private void fireInvalidate(boolean setModified) { + if (updating || initializing) { + suppressedInvalidate = true; + } else { + if (setModified) { + modified = true; + } + if (listeners.hasListeners()) { + GpxDataChangeEvent e = new GpxDataChangeEvent(this); + listeners.fireEvent(l -> l.gpxDataChanged(e)); + } + } + } + + /** + * Begins updating this GpxData and prevents listeners from being fired. + * @since 15496 + */ + public void beginUpdate() { + updating = true; + } + + /** + * Finishes updating this GpxData and fires listeners if required. + * @since 15496 + */ + public void endUpdate() { + boolean setModified = updating; + updating = initializing = false; + if (suppressedInvalidate) { + fireInvalidate(setModified); + suppressedInvalidate = false; } } @@ -1068,3 +1169,113 @@ } } + + /** + * @return whether anything has been modified (e.g. colors) + * @since 15496 + */ + public boolean isModified() { + return modified; + } + + /** + * Sets the modified flag to the value. + * @param value modified flag + * @since 15496 + */ + public void setModified(boolean value) { + modified = value; + } + + /** + * A class containing prefix, URI and location of a namespace + * @since 15496 + */ + public static class XMLNamespace { + private final String uri, prefix; + private String location; + + /** + * Creates a schema with prefix and URI, tries to determine prefix from URI + * @param fallbackPrefix the namespace prefix, if not determined from URI + * @param uri the namespace URI + */ + public XMLNamespace(String fallbackPrefix, String uri) { + this.prefix = Optional.ofNullable(GpxExtension.findPrefix(uri)).orElse(fallbackPrefix); + this.uri = uri; + } + + /** + * Creates a schema with prefix, URI and location. + * Does NOT try to determine prefix from URI! + * @param prefix + * @param uri + * @param location + */ + public XMLNamespace(String prefix, String uri, String location) { + this.prefix = prefix; + this.uri = uri; + this.location = location; + } + + /** + * @return the URI of the namesapce + */ + public String getURI() { + return uri; + } + + /** + * @return the prefix of the namespace, determined from URI if possible + */ + public String getPrefix() { + return prefix; + } + + /** + * @return the location of the schema + */ + public String getLocation() { + return location; + } + + /** + * Sets the location of the schema + * @param location the location of the schema + */ + public void setLocation(String location) { + this.location = location; + } + + @Override + public int hashCode() { + return Objects.hash(prefix, uri, location); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + XMLNamespace other = (XMLNamespace) obj; + if (prefix == null) { + if (other.prefix != null) + return false; + } else if (!prefix.equals(other.prefix)) + return false; + if (uri == null) { + if (other.uri != null) + return false; + } else if (!uri.equals(other.uri)) + return false; + if (location == null) { + if (other.location != null) + return false; + } else if (!location.equals(other.location)) + return false; + return true; + } + } } Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtension.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtension.java (revision 15496) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtension.java (revision 15496) @@ -0,0 +1,279 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import java.util.Objects; +import java.util.Optional; + +import org.openstreetmap.josm.data.gpx.GpxData.XMLNamespace; +import org.xml.sax.Attributes; + +/** + * A GpxExtension that has attributes and child extensions (implements {@link IWithAttributes}). + * @since 15496 + */ +public class GpxExtension extends WithAttributes implements IWithAttributes, GpxConstants { + private final String qualifiedName, prefix, key; + private IWithAttributes parent; + private String value; + private boolean visible = true; + + /** + * Constructs a new {@link GpxExtension}. + * @param prefix the prefix + * @param key the key + * @param value the value + */ + public GpxExtension(String prefix, String key, String value) { + this.prefix = Optional.ofNullable(prefix).orElse(""); + this.key = key; + this.value = value; + this.qualifiedName = (this.prefix.isEmpty() ? "" : this.prefix + ":") + key; + } + + /** + * Creates a new {@link GpxExtension} + * + * @param namespaceURI the URI of the XML namespace, used to determine supported extensions + * (josm, gpxx, gpxd) regardless of the prefix that could legally vary from file to file. + * @param qName the qualified name of the XML element including prefix + * @param atts the attributes + */ + public GpxExtension(String namespaceURI, String qName, Attributes atts) { + qualifiedName = qName; + int dot = qName.indexOf(':'); + String p = findPrefix(namespaceURI); + if (p == null) { + if (dot != -1) { + prefix = qName.substring(0, dot); + } else { + prefix = ""; + } + } else { + prefix = p; + } + key = qName.substring(dot + 1); + for (int i = 0; i < atts.getLength(); i++) { + attr.put(atts.getLocalName(i), atts.getValue(i)); + } + } + + /** + * Finds the default prefix used by JOSM for the given namespaceURI as the document is free specify another one. + * @param namespaceURI + * @return the prefix + */ + public static String findPrefix(String namespaceURI) { + if (XML_URI_EXTENSIONS_DRAWING.equals(namespaceURI)) + return "gpxd"; + + if (XML_URI_EXTENSIONS_GARMIN.equals(namespaceURI)) + return "gpxx"; + + if (XML_URI_EXTENSIONS_JOSM.equals(namespaceURI)) + return "josm"; + + return null; + } + + /** + * Finds the namespace for the given default prefix, if supported with schema location + * @param prefix the prefix used by JOSM + * @return the {@link XMLNamespace} element, location and URI can be null if not found. + */ + public static XMLNamespace findNamespace(String prefix) { + switch (prefix) { + case "gpxx": + return new XMLNamespace("gpxx", XML_URI_EXTENSIONS_GARMIN, XML_XSD_EXTENSIONS_GARMIN); + case "gpxd": + return new XMLNamespace("gpxd", XML_URI_EXTENSIONS_DRAWING, XML_XSD_EXTENSIONS_DRAWING); + case "josm": + return new XMLNamespace("josm", XML_URI_EXTENSIONS_JOSM, XML_XSD_EXTENSIONS_JOSM); + } + return null; + } + + /** + * @return the qualified name of the XML element + */ + public String getQualifiedName() { + return qualifiedName; + } + + /** + * @return the prefix of the XML namespace + */ + public String getPrefix() { + return prefix; + } + + /** + * @return the key (local element name) of the extension + */ + public String getKey() { + return key; + } + + /** + * @return the flattened extension key of this extension, used for conversion to OSM layers + */ + public String getFlatKey() { + String ret = ""; + if (parent != null && parent instanceof GpxExtension) { + GpxExtension ext = (GpxExtension) parent; + ret = ext.getFlatKey() + ":"; + } + return ret + getKey(); + } + + /** + * Searches recursively for the extension with the given key in all children + * @param sPrefix the prefix to look for + * @param sKey the key to look for + * @return the extension if found, otherwise null + */ + public GpxExtension findExtension(String sPrefix, String sKey) { + if (prefix.equalsIgnoreCase(sPrefix) && key.equalsIgnoreCase(sKey)) { + return this; + } else { + for (GpxExtension child : getExtensions()) { + GpxExtension ext = child.findExtension(sPrefix, sKey); + if (ext != null) { + return ext; + } + } + return null; + } + } + + /** + * @return the value of the extension + */ + public String getValue() { + return value; + } + + /** + * @param value the value to set + */ + public void setValue(String value) { + this.value = value; + } + + /** + * Removes this extension from its parent and all then-empty parents + * @throws IllegalStateException if parent not set + */ + public void remove() { + if (parent == null) + throw new IllegalStateException("Extension " + qualifiedName + " has no parent, can't remove it."); + + parent.getExtensions().remove(this); + if (parent instanceof GpxExtension) { + GpxExtension gpx = ((GpxExtension) parent); + if ((gpx.getValue() == null || gpx.getValue().trim().isEmpty()) + && gpx.getAttributes().isEmpty() + && gpx.getExtensions().isEmpty()) { + gpx.remove(); + } + } + } + + /** + * Hides this extension and all then-empty parents so it isn't written + * @see #isVisible() + */ + public void hide() { + visible = false; + if (parent != null && parent instanceof GpxExtension) { + GpxExtension gpx = (GpxExtension) parent; + if ((gpx.getValue() == null || gpx.getValue().trim().isEmpty()) + && gpx.getAttributes().isEmpty() + && !gpx.getExtensions().isVisible()) { + gpx.hide(); + } + } + } + + /** + * Shows this extension and all parents so it can be written + * @see #isVisible() + */ + public void show() { + visible = true; + if (parent != null && parent instanceof GpxExtension) { + ((GpxExtension) parent).show(); + } + } + + /** + * @return if this extension should be written, used for hiding colors during export without removing them + */ + public boolean isVisible() { + return visible; + } + + /** + * @return the parent element of this extension, can be another extension or gpx elements (data, track, segment, ...) + */ + public IWithAttributes getParent() { + return parent; + } + + /** + * Sets the parent for this extension + * @param parent the parent + * @throws IllegalStateException if parent already set + */ + public void setParent(IWithAttributes parent) { + if (this.parent != null) + throw new IllegalStateException("Parent of extension " + qualifiedName + " is already set"); + + this.parent = parent; + } + + @Override + public int hashCode() { + return Objects.hash(prefix, key, value, attr, parent, visible, super.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (!super.equals(obj)) + return false; + if (!(obj instanceof GpxExtension)) + return false; + GpxExtension other = (GpxExtension) obj; + if (visible != other.visible) + return false; + if (prefix == null) { + if (other.prefix != null) + return false; + } else if (!prefix.equals(other.prefix)) + return false; + if (key == null) { + if (other.key != null) + return false; + } else if (!key.equals(other.key)) + return false; + if (value == null) { + if (other.value != null) + return false; + } else if (!value.equals(other.value)) + return false; + if (attr == null) { + if (other.attr != null) + return false; + } else if (!attr.equals(other.attr)) + return false; + if (parent == null) { + if (other.parent != null) + return false; + } else if (!parent.equals(other.parent)) + return false; + return true; + } +} Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtensionCollection.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtensionCollection.java (revision 15496) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxExtensionCollection.java (revision 15496) @@ -0,0 +1,266 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Objects; +import java.util.Optional; +import java.util.Stack; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.apache.commons.jcs.access.exception.InvalidArgumentException; +import org.openstreetmap.josm.io.GpxReader; +import org.xml.sax.Attributes; + +/** + * Class extending ArrayList<GpxExtension>. + * Can be used to collect {@link GpxExtension}s while reading GPX files, see {@link GpxReader} + * @since 15496 + */ +public class GpxExtensionCollection extends ArrayList { + + private Stack childStack = new Stack<>(); + private IWithAttributes parent; + + /** + * Constructs a new {@link GpxExtensionCollection} + */ + public GpxExtensionCollection() {} + + /** + * Constructs a new {@link GpxExtensionCollection} with the given parent + * @param parent the parent extending {@link IWithAttributes} + */ + public GpxExtensionCollection(IWithAttributes parent) { + this.parent = parent; + } + + /** + * Adds a child extension to the last extension and pushes it to the stack. + * @param namespaceURI the URI of the XML namespace, used to determine supported + * extensions (josm, gpxx, gpxd) regardless of the prefix. + * @param qName the qualified name of the XML element including prefix + * @param atts the attributes + */ + public void openChild(String namespaceURI, String qName, Attributes atts) { + GpxExtension child = new GpxExtension(namespaceURI, qName, atts); + if (!childStack.isEmpty()) { + childStack.lastElement().getExtensions().add(child); + } else { + this.add(child); + } + childStack.add(child); + } + + /** + * Sets the value for the last child and pops it from the stack, so the next one will be added to its parent. + * The qualified name is verified. + * @param qName the qualified name + * @param value the value + */ + public void closeChild(String qName, String value) { + if (childStack.isEmpty()) + throw new InvalidArgumentException("Can't close child " + qName + ", no element in stack."); + + GpxExtension child = childStack.pop(); + + String childQN = child.getQualifiedName(); + + if (!childQN.equals(qName)) + throw new InvalidArgumentException("Can't close child " + qName + ", must close " + childQN + " first."); + + child.setValue(value); + } + + @Override + public boolean add(GpxExtension gpx) { + gpx.setParent(parent); + return super.add(gpx); + } + + /** + * Creates and adds a new {@link GpxExtension} from the given parameters. + * @param prefix the prefix + * @param key the key/tag + * @return the added GpxExtension + */ + public GpxExtension add(String prefix, String key) { + return add(prefix, key, null); + } + + /** + * Creates and adds a new {@link GpxExtension} from the given parameters. + * @param prefix the prefix + * @param key the key/tag + * @param value the value, can be null + * @return the added GpxExtension + */ + public GpxExtension add(String prefix, String key, String value) { + GpxExtension gpx = new GpxExtension(prefix, key, value); + add(gpx); + return gpx; + } + + /** + * Creates and adds a new {@link GpxExtension}, if it hasn't been added yet. Shows it if it has. + * @param prefix the prefix + * @param key the key/tag + * @return the added or found GpxExtension + * @see GpxExtension#show() + */ + public GpxExtension addIfNotPresent(String prefix, String key) { + GpxExtension gpx = get(prefix, key); + if (gpx != null) { + gpx.show(); + return gpx; + } + return add(prefix, key); + } + + /** + * Creates and adds a new {@link GpxExtension} or updates its value and shows it if already present. + * @param prefix the prefix + * @param key the key/tag + * @param value the value + * @return the added or found GpxExtension + * @see GpxExtension#show() + */ + public GpxExtension addOrUpdate(String prefix, String key, String value) { + GpxExtension gpx = get(prefix, key); + if (gpx != null) { + gpx.show(); + gpx.setValue(value); + return gpx; + } else { + return add(prefix, key, value); + } + } + + @Override + public boolean addAll(Collection extensions) { + extensions.forEach(e -> e.setParent(parent)); + return super.addAll(extensions); + } + + /** + * Adds an extension from a flat chain without prefix, e.g. when converting from OSM + * @param chain the full key chain, e.g. ["extension", "gpxx", "TrackExtensions", "DisplayColor"] + * @param value the value + */ + public void addFlat(String[] chain, String value) { + if (chain.length >= 3 && "extension".equals(chain[0])) { + String prefix = "other".equals(chain[1]) ? "" : chain[1]; + GpxExtensionCollection previous = this; + for (int i = 2; i < chain.length; i++) { + if (i != 2 || !"segment".equals(chain[2])) { + previous = previous.add(prefix, chain[i], i == chain.length - 1 ? value : null).getExtensions(); + } + } + } + } + + /** + * Gets the extension with the given prefix and key + * @param prefix the prefix + * @param key the key/tag + * @return the {@link GpxExtension} if found or null + */ + public GpxExtension get(String prefix, String key) { + return stream(prefix, key).findAny().orElse(null); + } + + /** + * Gets all extensions with the given prefix and key + * @param prefix the prefix + * @param key the key/tag + * @return a {@link GpxExtensionCollection} with the extensions, empty collection if none found + */ + public GpxExtensionCollection getAll(String prefix, String key) { + GpxExtensionCollection copy = new GpxExtensionCollection(this.parent); + copy.addAll(stream(prefix, key).collect(Collectors.toList())); + return copy; + } + + /** + * Gets a stream with all extensions with the given prefix and key + * @param prefix the prefix + * @param key the key/tag + * @return the Stream<{@link GpxExtension}> + */ + public Stream stream(String prefix, String key) { + return stream().filter(e -> Objects.equals(prefix, e.getPrefix()) && Objects.equals(key, e.getKey())); + } + + /** + * Searches recursively for the extension with the given prefix and key in all children + * @param prefix the prefix to look for + * @param key the key to look for + * @return the extension if found, otherwise null + */ + public GpxExtension find(String prefix, String key) { + for (GpxExtension child : this) { + GpxExtension ext = child.findExtension(prefix, key); + if (ext != null) { + return ext; + } + } + return null; + } + + /** + * Searches and removes recursively all extensions with the given prefix and key in all children + * @param prefix the prefix to look for + * @param key the key to look for + */ + public void findAndRemove(String prefix, String key) { + Optional.ofNullable(find(prefix, key)).ifPresent(GpxExtension::remove); + } + + /** + * Removes all {@link GpxExtension}s with the given prefix and key in direct children + * @param prefix the prefix + * @param key the key/tag + */ + public void remove(String prefix, String key) { + stream(prefix, key) + .collect(Collectors.toList()) //needs to be collected to avoid concurrent modification + .forEach(e -> super.remove(e)); + } + + /** + * Removes all extensions with the given prefix in direct children + * @param prefix the prefix + */ + public void removeAllWithPrefix(String prefix) { + stream() + .filter(e -> Objects.equals(prefix, e.getPrefix())) + .collect(Collectors.toList()) //needs to be collected to avoid concurrent modification + .forEach(e -> super.remove(e)); + } + + /** + * Gets all prefixes of direct (writable) children + * @return stream with the prefixes + */ + public Stream getPrefixesStream() { + return stream() + .filter(GpxExtension::isVisible) + .map(GpxExtension::getPrefix) + .distinct(); + } + + /** + * @return true if this collection contains writable extensions + */ + public boolean isVisible() { + return stream().anyMatch(GpxExtension::isVisible); + } + + @Override + public void clear() { + childStack.clear(); + super.clear(); + } + +} Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelation.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelation.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelation.java (revision 15496) @@ -40,5 +40,5 @@ for (GpxTrack trk : selectedGpx.tracks) { List> segs = new ArrayList<>(); - for (GpxTrackSegment seg : trk.getSegments()) { + for (IGpxTrackSegment seg : trk.getSegments()) { List wps = new ArrayList<>(seg.getWayPoints()); if (!wps.isEmpty()) { Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrack.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrack.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrack.java (revision 15496) @@ -2,66 +2,260 @@ package org.openstreetmap.josm.data.gpx; +import java.awt.Color; +import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; import org.openstreetmap.josm.data.Bounds; +import org.openstreetmap.josm.tools.ListenerList; +import org.openstreetmap.josm.tools.Logging; /** - * Read-only gpx track. Implementations doesn't have to be immutable, but should always be thread safe. - * @since 444 + * GPX track. + * Note that the color attributes are not immutable and may be modified by the user. + * @since 15496 */ -public interface GpxTrack extends IWithAttributes { - - /** - * Returns the track segments. - * @return the track segments - */ - Collection getSegments(); - - /** - * Returns the track attributes. - * @return the track attributes - */ - Map getAttributes(); - - /** - * Returns the track bounds. - * @return the track bounds - */ - Bounds getBounds(); - - /** - * Returns the track length. - * @return the track length - */ - double length(); - - /** - * Add a listener that listens to changes in the GPX track. - * @param l The listener - */ - default void addListener(GpxTrackChangeListener l) { - // nop - } - - /** - * Remove a listener that listens to changes in the GPX track. - * @param l The listener - */ - default void removeListener(GpxTrackChangeListener l) { - // nop +public class GpxTrack extends WithAttributes implements IGpxTrack { + + private final List segments; + private final double length; + private final Bounds bounds; + private Color colorCache; + private final ListenerList listeners = ListenerList.create(); + private static final HashMap closestGarminColorCache = new HashMap<>(); + private ColorFormat colorFormat; + + /** + * Constructs a new {@code GpxTrack}. + * @param trackSegs track segments + * @param attributes track attributes + */ + public GpxTrack(Collection> trackSegs, Map attributes) { + List newSegments = new ArrayList<>(); + for (Collection trackSeg: trackSegs) { + if (trackSeg != null && !trackSeg.isEmpty()) { + newSegments.add(new GpxTrackSegment(trackSeg)); + } + } + this.segments = Collections.unmodifiableList(newSegments); + this.length = calculateLength(); + this.bounds = calculateBounds(); + this.attr = new HashMap<>(attributes); + } + + /** + * Constructs a new {@code GpxTrack} from {@code GpxTrackSegment} objects. + * @param trackSegs The segments to build the track from. Input is not deep-copied, + * which means the caller may reuse the same segments to build + * multiple GpxTrack instances from. This should not be + * a problem, since this object cannot modify {@code this.segments}. + * @param attributes Attributes for the GpxTrack, the input map is copied. + */ + public GpxTrack(List trackSegs, Map attributes) { + this.attr = new HashMap<>(attributes); + this.segments = Collections.unmodifiableList(trackSegs); + this.length = calculateLength(); + this.bounds = calculateBounds(); + } + + private double calculateLength() { + double result = 0.0; // in meters + + for (IGpxTrackSegment trkseg : segments) { + result += trkseg.length(); + } + return result; + } + + private Bounds calculateBounds() { + Bounds result = null; + for (IGpxTrackSegment segment: segments) { + Bounds segBounds = segment.getBounds(); + if (segBounds != null) { + if (result == null) { + result = new Bounds(segBounds); + } else { + result.extend(segBounds); + } + } + } + return result; + } + + @Override + public void setColor(Color color) { + setColorExtension(color); + colorCache = color; + } + + private void setColorExtension(Color color) { + getExtensions().findAndRemove("gpxx", "DisplayColor"); + if (color == null) { + getExtensions().findAndRemove("gpxd", "color"); + } else { + getExtensions().addOrUpdate("gpxd", "color", String.format("#%02X%02X%02X", color.getRed(), color.getGreen(), color.getBlue())); + } + fireInvalidate(); + } + + @Override + public Color getColor() { + if (colorCache == null) { + colorCache = getColorFromExtension(); + } + return colorCache; + } + + private Color getColorFromExtension() { + GpxExtension gpxd = getExtensions().find("gpxd", "color"); + if (gpxd != null) { + colorFormat = ColorFormat.GPXD; + String cs = gpxd.getValue(); + try { + return Color.decode(cs); + } catch (NumberFormatException ex) { + Logging.warn("Could not read gpxd color: " + cs); + } + } else { + GpxExtension gpxx = getExtensions().find("gpxx", "DisplayColor"); + if (gpxx != null) { + colorFormat = ColorFormat.GPXX; + String cs = gpxx.getValue(); + if (cs != null) { + Color cc = GARMIN_COLORS.get(cs); + if (cc != null) { + return cc; + } + } + Logging.warn("Could not read garmin color: " + cs); + } + } + return null; + } + + /** + * Converts the color to the given format, if present. + * @param cFormat can be a {@link GpxConstants.ColorFormat} + */ + public void convertColor(ColorFormat cFormat) { + Color c = getColor(); + if (c == null) return; + + if (cFormat != this.colorFormat) { + if (cFormat == null) { + // just hide the extensions, don't actually remove them + Optional.ofNullable(getExtensions().find("gpxx", "DisplayColor")).ifPresent(GpxExtension::hide); + Optional.ofNullable(getExtensions().find("gpxd", "color")).ifPresent(GpxExtension::hide); + } else if (cFormat == ColorFormat.GPXX) { + getExtensions().findAndRemove("gpxd", "color"); + String colorString = null; + if (closestGarminColorCache.containsKey(c)) { + colorString = closestGarminColorCache.get(c); + } else { + //find closest garmin color + double closestDiff = -1; + for (Entry e : GARMIN_COLORS.entrySet()) { + double diff = colorDist(e.getValue(), c); + if (closestDiff < 0 || diff < closestDiff) { + colorString = e.getKey(); + closestDiff = diff; + if (closestDiff == 0) break; + } + } + } + closestGarminColorCache.put(c, colorString); + getExtensions().addIfNotPresent("gpxx", "TrackExtensions").getExtensions().addOrUpdate("gpxx", "DisplayColor", colorString); + } else if (cFormat == ColorFormat.GPXD) { + setColor(c); + } + colorFormat = cFormat; + } + } + + private double colorDist(Color c1, Color c2) { + // Simple Euclidean distance between two colors + return Math.sqrt(Math.pow(c1.getRed() - c2.getRed(), 2) + + Math.pow(c1.getGreen() - c2.getGreen(), 2) + + Math.pow(c1.getBlue() - c2.getBlue(), 2)); + } + + @Override + public void put(String key, Object value) { + super.put(key, value); + fireInvalidate(); + } + + private void fireInvalidate() { + listeners.fireEvent(l -> l.gpxDataChanged(new IGpxTrack.GpxTrackChangeEvent(this))); + } + + @Override + public Bounds getBounds() { + return bounds == null ? null : new Bounds(bounds); + } + + @Override + public double length() { + return length; + } + + @Override + public Collection getSegments() { + return segments; + } + + @Override + public int hashCode() { + return 31 * super.hashCode() + ((segments == null) ? 0 : segments.hashCode()); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + GpxTrack other = (GpxTrack) obj; + if (segments == null) { + if (other.segments != null) + return false; + } else if (!segments.equals(other.segments)) + return false; + return true; + } + + @Override + public void addListener(IGpxTrack.GpxTrackChangeListener l) { + listeners.addListener(l); + } + + @Override + public void removeListener(IGpxTrack.GpxTrackChangeListener l) { + listeners.removeListener(l); + } + + /** + * Resets the color cache + */ + public void invalidate() { + colorCache = null; } /** * A listener that listens to GPX track changes. - * @author Michael Zangl - * @since 12156 - */ + * @deprecated use {@link IGpxTrack.GpxTrackChangeListener} instead + */ + @Deprecated @FunctionalInterface interface GpxTrackChangeListener { - /** - * Called when the gpx data changed. - * @param e The event - */ void gpxDataChanged(GpxTrackChangeEvent e); } @@ -69,22 +263,12 @@ /** * A track change event for the current track. - * @author Michael Zangl - * @since 12156 - */ - class GpxTrackChangeEvent { - private final GpxTrack source; - - GpxTrackChangeEvent(GpxTrack source) { - super(); - this.source = source; - } - - /** - * Get the track that was changed. - * @return The track. - */ - public GpxTrack getSource() { - return source; - } - } + * @deprecated use {@link IGpxTrack.GpxTrackChangeEvent} instead + */ + @Deprecated + static class GpxTrackChangeEvent extends IGpxTrack.GpxTrackChangeEvent { + GpxTrackChangeEvent(IGpxTrack source) { + super(source); + } + } + } Index: /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrackSegment.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrackSegment.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/GpxTrackSegment.java (revision 15496) @@ -2,36 +2,103 @@ package org.openstreetmap.josm.data.gpx; +import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; +import java.util.List; import org.openstreetmap.josm.data.Bounds; /** - * Read-only gpx track segments. Implementations doesn't have to be immutable, but should always be thread safe. - * @since 2907 + * A gpx track segment consisting of multiple waypoints. + * @since 15496 */ -public interface GpxTrackSegment { +public class GpxTrackSegment extends WithAttributes implements IGpxTrackSegment { + + private final List wayPoints; + private final Bounds bounds; + private final double length; /** - * Returns the segment bounds. - * @return the segment bounds + * Constructs a new {@code GpxTrackSegment}. + * @param wayPoints list of waypoints */ - Bounds getBounds(); + public GpxTrackSegment(Collection wayPoints) { + this.wayPoints = Collections.unmodifiableList(new ArrayList<>(wayPoints)); + this.bounds = calculateBounds(); + this.length = calculateLength(); + } - /** - * Returns the segment waypoints. - * @return the segment waypoints - */ - Collection getWayPoints(); + private Bounds calculateBounds() { + Bounds result = null; + for (WayPoint wpt: wayPoints) { + if (result == null) { + result = new Bounds(wpt.getCoor()); + } else { + result.extend(wpt.getCoor()); + } + } + return result; + } - /** - * Returns the segment length. - * @return the segment length - */ - double length(); + private double calculateLength() { + double result = 0.0; // in meters + WayPoint last = null; + for (WayPoint tpt : wayPoints) { + if (last != null) { + Double d = last.getCoor().greatCircleDistance(tpt.getCoor()); + if (!d.isNaN() && !d.isInfinite()) { + result += d; + } + } + last = tpt; + } + return result; + } - /** - * Returns the number of times this track has been changed - * @return Number of times this track has been changed. Always 0 for read-only segments - */ - int getUpdateCount(); + @Override + public Bounds getBounds() { + return bounds == null ? null : new Bounds(bounds); + } + + @Override + public Collection getWayPoints() { + return Collections.unmodifiableList(wayPoints); + } + + @Override + public double length() { + return length; + } + + @Override + public int getUpdateCount() { + return 0; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = prime + super.hashCode(); + result = prime * result + ((wayPoints == null) ? 0 : wayPoints.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + GpxTrackSegment other = (GpxTrackSegment) obj; + if (wayPoints == null) { + if (other.wayPoints != null) + return false; + } else if (!wayPoints.equals(other.wayPoints)) + return false; + return true; + } } Index: /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrack.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrack.java (revision 15496) +++ /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrack.java (revision 15496) @@ -0,0 +1,100 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import java.awt.Color; +import java.util.Collection; + +import org.openstreetmap.josm.data.Bounds; + +/** + * Gpx track. Implementations don't have to be immutable, but should always be thread safe. + * @since 15496 + */ +public interface IGpxTrack extends IWithAttributes { + + /** + * Returns the track segments. + * @return the track segments + */ + Collection getSegments(); + + /** + * Returns the track bounds. + * @return the track bounds + */ + Bounds getBounds(); + + /** + * Returns the track length. + * @return the track length + */ + double length(); + + /** + * Gets the color of this track. + * @return The color, null if not set or not supported by the implementation. + * @since 15496 + */ + default Color getColor() { + return null; + } + + /** + * Sets the color of this track. Not necessarily supported by all implementations. + * @param color + * @since 15496 + */ + default void setColor(Color color) {} + + /** + * Add a listener that listens to changes in the GPX track. + * @param l The listener + */ + default void addListener(GpxTrackChangeListener l) { + // nop + } + + /** + * Remove a listener that listens to changes in the GPX track. + * @param l The listener + */ + default void removeListener(GpxTrackChangeListener l) { + // nop + } + + /** + * A listener that listens to GPX track changes. + * @author Michael Zangl + * @since 15496 + */ + @FunctionalInterface + interface GpxTrackChangeListener { + /** + * Called when the gpx data changed. + * @param e The event + */ + void gpxDataChanged(GpxTrackChangeEvent e); + } + + /** + * A track change event for the current track. + * @author Michael Zangl + * @since 15496 + */ + class GpxTrackChangeEvent { + private final IGpxTrack source; + + GpxTrackChangeEvent(IGpxTrack source) { + super(); + this.source = source; + } + + /** + * Get the track that was changed. + * @return The track. + */ + public IGpxTrack getSource() { + return source; + } + } +} Index: /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrackSegment.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrackSegment.java (revision 15496) +++ /trunk/src/org/openstreetmap/josm/data/gpx/IGpxTrackSegment.java (revision 15496) @@ -0,0 +1,37 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import java.util.Collection; + +import org.openstreetmap.josm.data.Bounds; + +/** + * Read-only gpx track segments. Implementations don't have to be immutable, but should always be thread safe. + * @since 15496 + */ +public interface IGpxTrackSegment extends IWithAttributes { + + /** + * Returns the segment bounds. + * @return the segment bounds + */ + Bounds getBounds(); + + /** + * Returns the segment waypoints. + * @return the segment waypoints + */ + Collection getWayPoints(); + + /** + * Returns the segment length. + * @return the segment length + */ + double length(); + + /** + * Returns the number of times this track has been changed + * @return Number of times this track has been changed. Always 0 for read-only segments + */ + int getUpdateCount(); +} Index: /trunk/src/org/openstreetmap/josm/data/gpx/IWithAttributes.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/IWithAttributes.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/IWithAttributes.java (revision 15496) @@ -3,4 +3,5 @@ import java.util.Collection; +import java.util.Map; /** @@ -51,10 +52,14 @@ /** - * Add a key / value pair that is not part of the GPX schema as an extension. - * - * @param key the key - * @param value the value + * Returns the attributes + * @return the attributes */ - void addExtension(String key, String value); + Map getAttributes(); + + /** + * Returns the extensions + * @return the extensions + */ + GpxExtensionCollection getExtensions(); } Index: /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrack.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrack.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrack.java (revision 15496) @@ -2,22 +2,15 @@ package org.openstreetmap.josm.data.gpx; -import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; import java.util.List; import java.util.Map; -import org.openstreetmap.josm.data.Bounds; - /** - * Immutable GPX track. + * GPX track, NOT immutable * @since 2907 + * @deprecated Use {@link GpxTrack} instead! */ -public class ImmutableGpxTrack extends WithAttributes implements GpxTrack { - - private final List segments; - private final double length; - private final Bounds bounds; +@Deprecated +public class ImmutableGpxTrack extends GpxTrack { /** @@ -27,14 +20,5 @@ */ public ImmutableGpxTrack(Collection> trackSegs, Map attributes) { - List newSegments = new ArrayList<>(); - for (Collection trackSeg: trackSegs) { - if (trackSeg != null && !trackSeg.isEmpty()) { - newSegments.add(new ImmutableGpxTrackSegment(trackSeg)); - } - } - this.attr = Collections.unmodifiableMap(new HashMap<>(attributes)); - this.segments = Collections.unmodifiableList(newSegments); - this.length = calculateLength(); - this.bounds = calculateBounds(); + super(trackSegs, attributes); } @@ -48,75 +32,6 @@ * @since 13210 */ - public ImmutableGpxTrack(List segments, Map attributes) { - this.attr = Collections.unmodifiableMap(new HashMap<>(attributes)); - this.segments = Collections.unmodifiableList(segments); - this.length = calculateLength(); - this.bounds = calculateBounds(); - } - - private double calculateLength() { - double result = 0.0; // in meters - - for (GpxTrackSegment trkseg : segments) { - result += trkseg.length(); - } - return result; - } - - private Bounds calculateBounds() { - Bounds result = null; - for (GpxTrackSegment segment: segments) { - Bounds segBounds = segment.getBounds(); - if (segBounds != null) { - if (result == null) { - result = new Bounds(segBounds); - } else { - result.extend(segBounds); - } - } - } - return result; - } - - @Override - public Map getAttributes() { - return attr; - } - - @Override - public Bounds getBounds() { - return bounds == null ? null : new Bounds(bounds); - } - - @Override - public double length() { - return length; - } - - @Override - public Collection getSegments() { - return segments; - } - - @Override - public int hashCode() { - return 31 * super.hashCode() + ((segments == null) ? 0 : segments.hashCode()); - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (!super.equals(obj)) - return false; - if (getClass() != obj.getClass()) - return false; - ImmutableGpxTrack other = (ImmutableGpxTrack) obj; - if (segments == null) { - if (other.segments != null) - return false; - } else if (!segments.equals(other.segments)) - return false; - return true; + public ImmutableGpxTrack(List segments, Map attributes) { + super(segments, attributes); } } Index: /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegment.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegment.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegment.java (revision 15496) @@ -2,19 +2,12 @@ package org.openstreetmap.josm.data.gpx; -import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; -import java.util.List; - -import org.openstreetmap.josm.data.Bounds; /** * A gpx track segment consisting of multiple waypoints, that cannot be changed. + * @deprecated Use {@link GpxTrackSegment} instead! */ -public class ImmutableGpxTrackSegment implements GpxTrackSegment { - - private final List wayPoints; - private final Bounds bounds; - private final double length; +@Deprecated +public class ImmutableGpxTrackSegment extends GpxTrackSegment { /** @@ -23,76 +16,5 @@ */ public ImmutableGpxTrackSegment(Collection wayPoints) { - this.wayPoints = Collections.unmodifiableList(new ArrayList<>(wayPoints)); - this.bounds = calculateBounds(); - this.length = calculateLength(); - } - - private Bounds calculateBounds() { - Bounds result = null; - for (WayPoint wpt: wayPoints) { - if (result == null) { - result = new Bounds(wpt.getCoor()); - } else { - result.extend(wpt.getCoor()); - } - } - return result; - } - - private double calculateLength() { - double result = 0.0; // in meters - WayPoint last = null; - for (WayPoint tpt : wayPoints) { - if (last != null) { - Double d = last.getCoor().greatCircleDistance(tpt.getCoor()); - if (!d.isNaN() && !d.isInfinite()) { - result += d; - } - } - last = tpt; - } - return result; - } - - @Override - public Bounds getBounds() { - return bounds == null ? null : new Bounds(bounds); - } - - @Override - public Collection getWayPoints() { - return Collections.unmodifiableList(wayPoints); - } - - @Override - public double length() { - return length; - } - - @Override - public int getUpdateCount() { - return 0; - } - - @Override - public int hashCode() { - return 31 + ((wayPoints == null) ? 0 : wayPoints.hashCode()); - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - ImmutableGpxTrackSegment other = (ImmutableGpxTrackSegment) obj; - if (wayPoints == null) { - if (other.wayPoints != null) - return false; - } else if (!wayPoints.equals(other.wayPoints)) - return false; - return true; + super(wayPoints); } } Index: /trunk/src/org/openstreetmap/josm/data/gpx/Line.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/Line.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/Line.java (revision 15496) @@ -2,4 +2,5 @@ package org.openstreetmap.josm.data.gpx; +import java.awt.Color; import java.util.Collection; import java.util.Iterator; @@ -14,4 +15,5 @@ private final Collection waypoints; private final boolean unordered; + private final Color color; /** @@ -19,6 +21,9 @@ * @param waypoints collection of waypoints * @param attributes track/route attributes + * @param color color of the track + * @since 15496 */ - public Line(Collection waypoints, Map attributes) { + public Line(Collection waypoints, Map attributes, Color color) { + this.color = color; this.waypoints = Objects.requireNonNull(waypoints); unordered = attributes.isEmpty() && waypoints.stream().allMatch(x -> x.get(GpxConstants.PT_TIME) == null); @@ -29,7 +34,9 @@ * @param trackSegment track segment * @param trackAttributes track attributes + * @param color color of the track + * @since 15496 */ - public Line(GpxTrackSegment trackSegment, Map trackAttributes) { - this(trackSegment.getWayPoints(), trackAttributes); + public Line(IGpxTrackSegment trackSegment, Map trackAttributes, Color color) { + this(trackSegment.getWayPoints(), trackAttributes, color); } @@ -39,5 +46,5 @@ */ public Line(GpxRoute route) { - this(route.routePoints, route.attr); + this(route.routePoints, route.attr, null); } @@ -48,4 +55,13 @@ public boolean isUnordered() { return unordered; + } + + /** + * Returns the track/route color + * @return the color + * @since 15496 + */ + public Color getColor() { + return color; } Index: /trunk/src/org/openstreetmap/josm/data/gpx/WithAttributes.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/gpx/WithAttributes.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/gpx/WithAttributes.java (revision 15496) @@ -5,4 +5,5 @@ import java.util.HashMap; import java.util.Map; +import java.util.Objects; /** @@ -20,4 +21,9 @@ */ public Map attr = new HashMap<>(0); + + /** + * The "exts" collection contains all extensions. + */ + private final GpxExtensionCollection exts = new GpxExtensionCollection(this); /** @@ -65,5 +71,4 @@ /** * Put a key / value pair as a new attribute. - * * Overrides key / value pair with the same key (if present). * @@ -76,22 +81,17 @@ } - /** - * Add a key / value pair that is not part of the GPX schema as an extension. - * - * @param key the key - * @param value the value - */ @Override - public void addExtension(String key, String value) { - if (!attr.containsKey(META_EXTENSIONS)) { - attr.put(META_EXTENSIONS, new Extensions()); - } - Extensions ext = (Extensions) attr.get(META_EXTENSIONS); - ext.put(key, value); + public Map getAttributes() { + return attr; + } + + @Override + public GpxExtensionCollection getExtensions() { + return exts; } @Override public int hashCode() { - return 31 + ((attr == null) ? 0 : attr.hashCode()); + return Objects.hash(attr, exts); } @@ -110,4 +110,9 @@ } else if (!attr.equals(other.attr)) return false; + if (exts == null) { + if (other.exts != null) + return false; + } else if (!exts.equals(other.exts)) + return false; return true; } Index: /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 15496) @@ -33,4 +33,5 @@ import org.openstreetmap.josm.data.coor.EastNorth; import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.gpx.GpxData.XMLNamespace; import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionAddEvent; import org.openstreetmap.josm.data.osm.DataSelectionListener.SelectionChangeEvent; @@ -171,4 +172,10 @@ /** + * Used to temporarily store namespaces from the GPX file in case the user converts back and forth. + * Will not be saved to .osm files, but that's not necessary because GPX files won't automatically be overridden after that. + */ + private List GPXNamespaces; + + /** * Constructs a new {@code DataSet}. */ @@ -1195,4 +1202,20 @@ /** + * Gets the GPX (XML) namespaces if this DataSet was created from a GPX file + * @return the GPXNamespaces or null + */ + public List getGPXNamespaces() { + return GPXNamespaces; + } + + /** + * Sets the GPX (XML) namespaces + * @param GPXNamespaces the GPXNamespaces to set + */ + public void setGPXNamespaces(List GPXNamespaces) { + this.GPXNamespaces = GPXNamespaces; + } + + /** * @return true if this Dataset contains no primitives * @since 14835 Index: /trunk/src/org/openstreetmap/josm/data/preferences/NamedColorProperty.java =================================================================== --- /trunk/src/org/openstreetmap/josm/data/preferences/NamedColorProperty.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/data/preferences/NamedColorProperty.java (revision 15496) @@ -23,5 +23,4 @@ public static final String COLOR_CATEGORY_GENERAL = "general"; public static final String COLOR_CATEGORY_MAPPAINT = "mappaint"; - public static final String COLOR_CATEGORY_LAYER = "layer"; private final String category; @@ -32,6 +31,5 @@ * Construct a new {@code NamedColorProperty}. * @param category a category, can be any identifier, but the following values are recognized by - * the GUI preferences: {@link #COLOR_CATEGORY_GENERAL}, {@link #COLOR_CATEGORY_MAPPAINT} and - * {@link #COLOR_CATEGORY_LAYER} + * the GUI preferences: {@link #COLOR_CATEGORY_GENERAL} and {@link #COLOR_CATEGORY_MAPPAINT} * @param source a filename or similar associated with the color, can be null if not applicable * @param name a short description of the color Index: /trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java (revision 15496) @@ -4,5 +4,4 @@ import static org.openstreetmap.josm.tools.I18n.tr; -import java.awt.Color; import java.awt.Component; import java.awt.Dimension; @@ -18,5 +17,5 @@ import java.util.Arrays; import java.util.List; -import java.util.Objects; +import java.util.Optional; import java.util.concurrent.CopyOnWriteArrayList; @@ -43,5 +42,4 @@ import org.openstreetmap.josm.data.coor.EastNorth; import org.openstreetmap.josm.data.imagery.OffsetBookmark; -import org.openstreetmap.josm.data.preferences.AbstractProperty; import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener; import org.openstreetmap.josm.data.preferences.BooleanProperty; @@ -612,16 +610,7 @@ } if (Config.getPref().getBoolean("dialog.layer.colorname", true)) { - AbstractProperty prop = layer.getColorProperty(); - Color c = prop == null ? null : prop.get(); - if (c == null || model.getLayers().stream() - .map(Layer::getColorProperty) - .filter(Objects::nonNull) - .map(AbstractProperty::get) - .noneMatch(oc -> oc != null && !oc.equals(c))) { - /* not more than one color, don't use coloring */ - label.setForeground(UIManager.getColor(isSelected ? "Table.selectionForeground" : "Table.foreground")); - } else { - label.setForeground(c); - } + label.setForeground(Optional + .ofNullable(layer.getColor()) + .orElse(UIManager.getColor(isSelected ? "Table.selectionForeground" : "Table.foreground"))); } label.setIcon(layer.getIcon()); Index: /trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerVisibilityAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerVisibilityAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerVisibilityAction.java (revision 15496) @@ -594,5 +594,5 @@ for (Layer l : layers) { if (l instanceof GpxLayer) { - l.getColorProperty().put(color); + l.setColor(color); } } @@ -603,5 +603,5 @@ panels.put(color, colorPanel); - List colors = layerSupplier.get().stream().map(l -> l.getColorProperty().get()).distinct().collect(Collectors.toList()); + List colors = layerSupplier.get().stream().map(l -> l.getColor()).distinct().collect(Collectors.toList()); if (colors.size() == 1) { highlightColor(colors.get(0)); @@ -612,5 +612,5 @@ public void updateLayers(List layers, boolean allVisible, boolean allHidden) { List colors = layers.stream().filter(l -> l instanceof GpxLayer) - .map(l -> ((GpxLayer) l).getColorProperty().get()) + .map(l -> ((GpxLayer) l).getColor()) .distinct() .collect(Collectors.toList()); Index: /trunk/src/org/openstreetmap/josm/gui/io/importexport/FileExporter.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/io/importexport/FileExporter.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/io/importexport/FileExporter.java (revision 15496) @@ -56,4 +56,16 @@ /** + * Execute the data export without prompting the user. (To be overridden by subclasses.) + * + * @param file target file + * @param layer the layer to export + * @throws IOException in case of an IO error + * @since 15496 + */ + public void exportDataQuiet(File file, Layer layer) throws IOException { + exportData(file, layer); //backwards compatibility + } + + /** * Returns the enabled state of this {@code FileExporter}. When enabled, it is listed and usable in "File->Save" dialogs. * @return true if this {@code FileExporter} is enabled Index: /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxExporter.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxExporter.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxExporter.java (revision 15496) @@ -26,4 +26,5 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil; import org.openstreetmap.josm.gui.ExtendedDialog; import org.openstreetmap.josm.gui.MainApplication; @@ -78,4 +79,13 @@ @Override public void exportData(File file, Layer layer) throws IOException { + exportData(file, layer, false); + } + + @Override + public void exportDataQuiet(File file, Layer layer) throws IOException { + exportData(file, layer, true); + } + + private void exportData(File file, Layer layer, boolean quiet) throws IOException { CheckParameterUtil.ensureParameterNotNull(layer, "layer"); if (!(layer instanceof OsmDataLayer) && !(layer instanceof GpxLayer)) @@ -90,8 +100,19 @@ } + GpxData gpxData; + if (quiet) { + gpxData = getGpxData(layer, file); + try (OutputStream fo = Compression.getCompressedFileOutputStream(file)) { + GpxWriter w = new GpxWriter(fo); + w.write(gpxData); + w.close(); + fo.flush(); + } + return; + } + // open the dialog asking for options JPanel p = new JPanel(new GridBagLayout()); - GpxData gpxData; // At this moment, we only need to know the attributes of the GpxData, // conversion of OsmDataLayer (if needed) will be done after the dialog is closed. @@ -147,5 +168,19 @@ JosmTextField keywords = new JosmTextField(); keywords.setText(gpxData.getString(META_KEYWORDS)); - p.add(keywords, GBC.eop().fill(GBC.HORIZONTAL)); + p.add(keywords, GBC.eol().fill(GBC.HORIZONTAL)); + + boolean sel = Config.getPref().getBoolean("gpx.export.colors", true); + JCheckBox colors = new JCheckBox(tr("Save track colors in GPX file"), sel); + p.add(colors, GBC.eol().fill(GBC.HORIZONTAL)); + JCheckBox garmin = new JCheckBox(tr("Use Garmin compatible GPX extensions"), + Config.getPref().getBoolean("gpx.export.colors.garmin", false)); + garmin.setEnabled(sel); + p.add(garmin, GBC.eol().fill(GBC.HORIZONTAL).insets(20, 0, 0, 0)); + + boolean hasPrefs = !gpxData.getLayerPrefs().isEmpty(); + JCheckBox layerPrefs = new JCheckBox(tr("Save layer specific preferences"), + hasPrefs && Config.getPref().getBoolean("gpx.export.prefs", true)); + layerPrefs.setEnabled(hasPrefs); + p.add(layerPrefs, GBC.eop().fill(GBC.HORIZONTAL)); ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(), @@ -155,4 +190,22 @@ .setContent(p); + colors.addActionListener(l -> { + garmin.setEnabled(colors.isSelected()); + }); + + garmin.addActionListener(l -> { + if (garmin.isSelected() && + !ConditionalOptionPaneUtil.showConfirmationDialog( + "gpx_color_garmin", + ed, + new JLabel(tr("Garmin track extensions only support 16 colors.
If you continue, the closest supported track color will be used.")), + tr("Information"), + JOptionPane.OK_CANCEL_OPTION, + JOptionPane.INFORMATION_MESSAGE, + JOptionPane.OK_OPTION)) { + garmin.setSelected(false); + } + }); + if (ed.showDialog().getValue() != 1) { setCanceled(true); @@ -168,12 +221,15 @@ Config.getPref().put("lastCopyright", copyright.getText()); } - - if (layer instanceof OsmDataLayer) { - gpxData = ((OsmDataLayer) layer).toGpxData(); - } else if (layer instanceof GpxLayer) { - gpxData = ((GpxLayer) layer).data; - } else { - gpxData = OsmDataLayer.toGpxData(MainApplication.getLayerManager().getEditDataSet(), file); - } + Config.getPref().putBoolean("gpx.export.colors", colors.isSelected()); + Config.getPref().putBoolean("gpx.export.colors.garmin", garmin.isSelected()); + if (hasPrefs) { + Config.getPref().putBoolean("gpx.export.prefs", layerPrefs.isSelected()); + } + ColorFormat cFormat = null; + if (colors.isSelected()) { + cFormat = garmin.isSelected() ? ColorFormat.GPXX : ColorFormat.GPXD; + } + + gpxData = getGpxData(layer, file); // add author and copyright details to the gpx data @@ -204,7 +260,19 @@ } - try (OutputStream fo = Compression.getCompressedFileOutputStream(file); GpxWriter writer = new GpxWriter(fo)) { - writer.write(gpxData); - } + try (OutputStream fo = Compression.getCompressedFileOutputStream(file)) { + GpxWriter w = new GpxWriter(fo); + w.write(gpxData, cFormat, layerPrefs.isSelected()); + w.close(); + fo.flush(); + } + } + + private static GpxData getGpxData(Layer layer, File file) { + if (layer instanceof OsmDataLayer) { + return ((OsmDataLayer) layer).toGpxData(); + } else if (layer instanceof GpxLayer) { + return ((GpxLayer) layer).data; + } + return OsmDataLayer.toGpxData(MainApplication.getLayerManager().getEditDataSet(), file); } Index: /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxImporter.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxImporter.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxImporter.java (revision 15496) @@ -150,4 +150,6 @@ if (markerLayer.data.isEmpty()) { markerLayer = null; + } else { + gpxLayer.setLinkedMarkerLayer(markerLayer); } } Index: /trunk/src/org/openstreetmap/josm/gui/layer/CustomizeColor.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/CustomizeColor.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/CustomizeColor.java (revision 15496) @@ -19,10 +19,8 @@ import javax.swing.JOptionPane; -import org.openstreetmap.josm.data.preferences.AbstractProperty; import org.openstreetmap.josm.gui.MainApplication; import org.openstreetmap.josm.gui.dialogs.LayerListDialog; import org.openstreetmap.josm.gui.layer.Layer.LayerAction; import org.openstreetmap.josm.gui.layer.Layer.MultiLayerAction; -import org.openstreetmap.josm.tools.CheckParameterUtil; import org.openstreetmap.josm.tools.ImageProvider; @@ -34,5 +32,5 @@ */ public class CustomizeColor extends AbstractAction implements LayerAction, MultiLayerAction { - private final transient List> colors; + private final transient List colorLayers; /** @@ -43,6 +41,5 @@ super(tr("Customize Color")); new ImageProvider("colorchooser").getResource().attachImageIcon(this, true); - colors = l.stream().map(Layer::getColorProperty).collect(Collectors.toList()); - CheckParameterUtil.ensureThat(colors.stream().allMatch(Objects::nonNull), "All layers must have colors."); + colorLayers = l.stream().filter(Objects::nonNull).filter(Layer::hasColor).collect(Collectors.toList()); putValue("help", ht("/Action/LayerCustomizeColor")); } @@ -58,5 +55,5 @@ @Override public boolean supportLayers(List layers) { - return layers.stream().allMatch(l -> l.getColorProperty() != null); + return layers.stream().allMatch(Layer::hasColor); } @@ -73,5 +70,5 @@ @Override public void actionPerformed(ActionEvent e) { - Color cl = colors.stream().map(AbstractProperty::get).filter(Objects::nonNull).findAny().orElse(Color.GRAY); + Color cl = colorLayers.stream().filter(Objects::nonNull).map(Layer::getColor).filter(Objects::nonNull).findAny().orElse(Color.GRAY); JColorChooser c = new JColorChooser(cl); Object[] options = new Object[]{tr("OK"), tr("Cancel"), tr("Default")}; @@ -88,10 +85,10 @@ switch (answer) { case 0: - colors.stream().forEach(prop -> prop.put(c.getColor())); + colorLayers.stream().forEach(l -> l.setColor(c.getColor())); break; case 1: return; case 2: - colors.stream().forEach(prop -> prop.put(null)); + colorLayers.stream().forEach(l -> l.setColor(null)); break; } Index: /trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java (revision 15496) @@ -5,4 +5,5 @@ import static org.openstreetmap.josm.tools.I18n.trn; +import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics2D; @@ -14,4 +15,5 @@ import java.util.Date; import java.util.List; +import java.util.stream.Collectors; import javax.swing.AbstractAction; @@ -32,5 +34,4 @@ import org.openstreetmap.josm.data.gpx.GpxTrack; import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor; -import org.openstreetmap.josm.data.preferences.NamedColorProperty; import org.openstreetmap.josm.data.projection.Projection; import org.openstreetmap.josm.gui.MapView; @@ -47,6 +48,9 @@ import org.openstreetmap.josm.gui.layer.gpx.ImportImagesAction; import org.openstreetmap.josm.gui.layer.gpx.MarkersFromNamedPointsAction; +import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer; +import org.openstreetmap.josm.gui.preferences.display.GPXSettingsPanel; import org.openstreetmap.josm.gui.widgets.HtmlPanel; import org.openstreetmap.josm.tools.ImageProvider; +import org.openstreetmap.josm.tools.Logging; import org.openstreetmap.josm.tools.Utils; import org.openstreetmap.josm.tools.date.DateUtils; @@ -55,10 +59,11 @@ * A layer that displays data from a Gpx file / the OSM gpx downloads. */ -public class GpxLayer extends Layer implements ExpertModeChangeListener { +public class GpxLayer extends AbstractModifiableLayer implements ExpertModeChangeListener { /** GPX data */ public GpxData data; - private final boolean isLocalFile; + private boolean isLocalFile; private boolean isExpertMode; + /** * used by {@link ChooseTrackVisibilityAction} to determine which tracks to show/hide @@ -73,4 +78,8 @@ */ private final GpxDataChangeListener dataChangeListener = e -> this.invalidate(); + /** + * The MarkerLayer imported from the same file. + */ + private MarkerLayer linkedMarkerLayer; /** @@ -109,6 +118,22 @@ @Override - protected NamedColorProperty getBaseColorProperty() { - return GpxDrawHelper.DEFAULT_COLOR; + public Color getColor() { + Color[] c = data.getTracks().stream().map(t -> t.getColor()).distinct().toArray(Color[]::new); + return c.length == 1 ? c[0] : null; //only return if exactly one distinct color present + } + + @Override + public void setColor(Color color) { + data.beginUpdate(); + for (GpxTrack trk : data.getTracks()) { + trk.setColor(color); + } + GPXSettingsPanel.putLayerPrefLocal(this, "colormode", "0"); + data.endUpdate(); + } + + @Override + public boolean hasColor() { + return true; } @@ -277,6 +302,13 @@ .append(trn("{0} route, ", "{0} routes, ", data.getRoutes().size(), data.getRoutes().size())) .append(trn("{0} waypoint", "{0} waypoints", data.getWaypoints().size(), data.getWaypoints().size())).append("
") - .append(tr("Length: {0}", SystemOfMeasurement.getSystemOfMeasurement().getDistText(data.length()))) - .append("
"); + .append(tr("Length: {0}", SystemOfMeasurement.getSystemOfMeasurement().getDistText(data.length()))); + + if (Logging.isDebugEnabled() && !data.getLayerPrefs().isEmpty()) { + info.append("

") + .append(String.join("
", data.getLayerPrefs().entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.toList()))); + } + + info.append("
"); + return info.toString(); } @@ -340,4 +372,20 @@ public void setAssociatedFile(File file) { data.storageFile = file; + } + + /** + * @return the linked MarkerLayer (imported from the same file) + * @since 15496 + */ + public MarkerLayer getLinkedMarkerLayer() { + return linkedMarkerLayer; + } + + /** + * @param linkedMarkerLayer the linked MarkerLayer + * @since 15496 + */ + public void setLinkedMarkerLayer(MarkerLayer linkedMarkerLayer) { + this.linkedMarkerLayer = linkedMarkerLayer; } @@ -481,4 +529,21 @@ @Override + public boolean isModified() { + return data.isModified(); + } + + @Override + public boolean requiresSaveToFile() { + return isModified() && isLocalFile(); + } + + @Override + public void onPostSaveToFile() { + isLocalFile = true; + data.invalidate(); + data.setModified(false); + } + + @Override public String getChangesetSourceTag() { // no i18n for international values Index: /trunk/src/org/openstreetmap/josm/gui/layer/Layer.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/Layer.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/Layer.java (revision 15496) @@ -26,7 +26,4 @@ import org.openstreetmap.josm.data.ProjectionBounds; import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor; -import org.openstreetmap.josm.data.preferences.AbstractProperty; -import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener; -import org.openstreetmap.josm.data.preferences.NamedColorProperty; import org.openstreetmap.josm.data.projection.Projection; import org.openstreetmap.josm.data.projection.ProjectionChangeListener; @@ -165,5 +162,4 @@ private File associatedFile; - private final ValueChangeListener invalidateListener = change -> invalidate(); private boolean isDestroyed; @@ -199,38 +195,26 @@ /** - * Gets the color property to use for this layer. - * @return The color property. - * @since 10824 - */ - public AbstractProperty getColorProperty() { - NamedColorProperty base = getBaseColorProperty(); - if (base != null) { - return base.getChildColor(NamedColorProperty.COLOR_CATEGORY_LAYER, getName(), base.getName()); - } else { - return null; - } - } - - /** - * Gets the color property that stores the default color for this layer. - * @return The property or null if this layer is not colored. - * @since 10824 - */ - protected NamedColorProperty getBaseColorProperty() { + * @return whether the layer has / can handle colors. + * @since 15496 + */ + public boolean hasColor() { + return false; + } + + /** + * Return the current color of the layer + * @return null when not present or not supported + * @since 15496 + */ + public Color getColor() { return null; } - private void addColorPropertyListener() { - AbstractProperty colorProperty = getColorProperty(); - if (colorProperty != null) { - colorProperty.addListener(invalidateListener); - } - } - - private void removeColorPropertyListener() { - AbstractProperty colorProperty = getColorProperty(); - if (colorProperty != null) { - colorProperty.removeListener(invalidateListener); - } + /** + * Sets the color for this layer. Nothing happens if not supported by the layer + * @param color the color to be set, null for default + * @since 15496 + */ + public void setColor(Color color) { } @@ -303,5 +287,4 @@ isDestroyed = true; // Override in subclasses if needed - removeColorPropertyListener(); } @@ -340,7 +323,4 @@ */ public void setName(String name) { - if (this.name != null) { - removeColorPropertyListener(); - } String oldValue = this.name; this.name = Optional.ofNullable(name).orElse(""); @@ -348,7 +328,4 @@ propertyChangeSupport.firePropertyChange(NAME_PROP, oldValue, this.name); } - - // re-add listener - addColorPropertyListener(); invalidate(); } @@ -540,5 +517,5 @@ @Override public void actionPerformed(ActionEvent e) { - SaveAction.getInstance().doSave(layer); + SaveAction.getInstance().doSave(layer, true); } } Index: /trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java (revision 15496) @@ -32,4 +32,5 @@ import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Optional; import java.util.Set; @@ -61,6 +62,9 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxExtensionCollection; import org.openstreetmap.josm.data.gpx.GpxLink; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.DataIntegrityProblemException; @@ -758,4 +762,7 @@ public static GpxData toGpxData(DataSet data, File file) { GpxData gpxData = new GpxData(); + if (data.getGPXNamespaces() != null) { + gpxData.getNamespaces().addAll(data.getGPXNamespaces()); + } gpxData.storageFile = file; Set doneNodes = new HashSet<>(); @@ -778,21 +785,40 @@ return; } - Collection> trk = new ArrayList<>(); + List trk = new ArrayList<>(); Map trkAttr = new HashMap<>(); - String name = gpxVal(w, "name"); - if (name != null) { - trkAttr.put("name", name); - } - - List trkseg = null; + GpxExtensionCollection trkExts = new GpxExtensionCollection(); + GpxExtensionCollection segExts = new GpxExtensionCollection(); + for (Entry e : w.getKeys().entrySet()) { + String k = e.getKey().startsWith(GpxConstants.GPX_PREFIX) ? e.getKey().substring(GpxConstants.GPX_PREFIX.length()) : e.getKey(); + String v = e.getValue(); + if (GpxConstants.RTE_TRK_KEYS.contains(k)) { + trkAttr.put(k, v); + } else { + k = GpxConstants.EXTENSION_ABBREVIATIONS.entrySet() + .stream() + .filter(s -> s.getValue().equals(e.getKey())) + .map(s -> s.getKey().substring(GpxConstants.GPX_PREFIX.length())) + .findAny() + .orElse(k); + if (k.startsWith("extension")) { + String[] chain = k.split(":"); + if (chain.length >= 3 && "segment".equals(chain[2])) { + segExts.addFlat(chain, v); + } else { + trkExts.addFlat(chain, v); + } + } + + } + } + List trkseg = new ArrayList<>(); for (Node n : w.getNodes()) { if (!n.isUsable()) { - trkseg = null; + if (!trkseg.isEmpty()) { + trk.add(new GpxTrackSegment(trkseg)); + trkseg.clear(); + } continue; - } - if (trkseg == null) { - trkseg = new ArrayList<>(); - trk.add(trkseg); } if (!n.isTagged() || containsOnlyGpxTags(n)) { @@ -801,6 +827,9 @@ trkseg.add(nodeToWayPoint(n)); } - - gpxData.addTrack(new ImmutableGpxTrack(trk, trkAttr)); + trk.add(new GpxTrackSegment(trkseg)); + trk.forEach(gpxseg -> gpxseg.getExtensions().addAll(segExts)); + GpxTrack gpxtrk = new GpxTrack(trk, trkAttr); + gpxtrk.getExtensions().addAll(trkExts); + gpxData.addTrack(gpxtrk); }); } Index: /trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java (revision 15496) @@ -71,5 +71,5 @@ import org.openstreetmap.josm.data.gpx.GpxTimezone; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor; @@ -1269,5 +1269,5 @@ // Finds first GPX point outer: for (GpxTrack trk : gpx.tracks) { - for (GpxTrackSegment segment : trk.getSegments()) { + for (IGpxTrackSegment segment : trk.getSegments()) { for (WayPoint curWp : segment.getWayPoints()) { if (curWp.hasDate()) { Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java (revision 15496) @@ -5,4 +5,5 @@ import static org.openstreetmap.josm.tools.I18n.tr; +import java.awt.Color; import java.awt.Component; import java.awt.Dimension; @@ -13,12 +14,17 @@ import java.awt.event.MouseListener; import java.io.Serializable; +import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; +import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import javax.swing.AbstractAction; +import javax.swing.JColorChooser; import javax.swing.JComponent; import javax.swing.JLabel; +import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JScrollPane; @@ -26,8 +32,10 @@ import javax.swing.JToggleButton; import javax.swing.ListSelectionModel; +import javax.swing.event.TableModelEvent; import javax.swing.table.DefaultTableModel; import javax.swing.table.TableCellRenderer; import javax.swing.table.TableRowSorter; +import org.apache.commons.jcs.access.exception.InvalidArgumentException; import org.openstreetmap.josm.data.SystemOfMeasurement; import org.openstreetmap.josm.data.gpx.GpxConstants; @@ -36,4 +44,5 @@ import org.openstreetmap.josm.gui.MainApplication; import org.openstreetmap.josm.gui.layer.GpxLayer; +import org.openstreetmap.josm.gui.preferences.display.GPXSettingsPanel; import org.openstreetmap.josm.gui.util.WindowGeometry; import org.openstreetmap.josm.tools.GBC; @@ -56,5 +65,5 @@ */ public ChooseTrackVisibilityAction(final GpxLayer layer) { - super(tr("Choose visible tracks")); + super(tr("Choose track visibility and colors")); new ImageProvider("dialogs/filter").getResource().attachImageIcon(this, true); this.layer = layer; @@ -117,5 +126,5 @@ TrackLength length = new TrackLength(trk.length()); String url = (String) Optional.ofNullable(attr.get("url")).orElse(""); - tracks[i] = new Object[]{name, desc, time, length, url}; + tracks[i] = new Object[]{name, desc, time, length, url, trk}; i++; } @@ -123,6 +132,36 @@ } + private void showColorDialog(List tracks) { + Color cl = tracks.stream().filter(Objects::nonNull) + .map(GpxTrack::getColor).filter(Objects::nonNull) + .findAny().orElse(GpxDrawHelper.DEFAULT_COLOR_PROPERTY.get()); + JColorChooser c = new JColorChooser(cl); + Object[] options = new Object[]{tr("OK"), tr("Cancel"), tr("Default")}; + int answer = JOptionPane.showOptionDialog( + MainApplication.getMainFrame(), + c, + tr("Choose a color"), + JOptionPane.OK_CANCEL_OPTION, + JOptionPane.PLAIN_MESSAGE, + null, + options, + options[0] + ); + switch (answer) { + case 0: + tracks.stream().forEach(t -> t.setColor(c.getColor())); + GPXSettingsPanel.putLayerPrefLocal(layer, "colormode", "0"); //set Colormode to none + break; + case 1: + return; + case 2: + tracks.stream().forEach(t -> t.setColor(null)); + break; + } + table.repaint(); + } + /** - * Builds an non-editable table whose 5th column will open a browser when double clicked. + * Builds an editable table whose 5th column will open a browser when double clicked. * The table will fill its parent. * @param content table data @@ -139,4 +178,38 @@ JComponent jc = (JComponent) c; jc.setToolTipText(getValueAt(row, col).toString()); + if (content.length > row + && content[row].length > 5 + && content[row][5] instanceof GpxTrack) { + Color color = ((GpxTrack) content[row][5]).getColor(); + if (color != null) { + double brightness = Math.sqrt(Math.pow(color.getRed(), 2) * .241 + + Math.pow(color.getGreen(), 2) * .691 + + Math.pow(color.getBlue(), 2) * .068); + if (brightness > 250) { + color = color.darker(); + } + if (isRowSelected(row)) { + jc.setBackground(color); + if (brightness <= 130) { + jc.setForeground(Color.WHITE); + } else { + jc.setForeground(Color.BLACK); + } + } else { + if (brightness > 200) { + color = color.darker(); //brightness >250 is darkened twice on purpose + } + jc.setForeground(color); + jc.setBackground(Color.WHITE); + } + } else { + jc.setForeground(Color.BLACK); + if (isRowSelected(row)) { + jc.setBackground(new Color(175, 210, 210)); + } else { + jc.setBackground(Color.WHITE); + } + } + } } return c; @@ -145,5 +218,26 @@ @Override public boolean isCellEditable(int rowIndex, int colIndex) { - return false; + return colIndex <= 1; + } + + @Override + public void tableChanged(TableModelEvent e) { + super.tableChanged(e); + int col = e.getColumn(); + int row = e.getFirstRow(); + if (row >= 0 && row < content.length && col >= 0 && col <= 1) { + Object t = content[row][5]; + String val = (String) getValueAt(row, col); + if (t != null && t instanceof GpxTrack) { + GpxTrack trk = (GpxTrack) t; + if (col == 0) { + trk.put("name", val); + } else { + trk.put("desc", val); + } + } else { + throw new InvalidArgumentException("Invalid object in table, must be GpxTrack."); + } + } } }; @@ -181,4 +275,5 @@ t.addMouseListener(urlOpener); t.setFillsViewportHeight(true); + t.putClientProperty("terminateEditOnFocusLost", true); return t; } @@ -250,9 +345,11 @@ msg.add(new JLabel(tr("Select all tracks that you want to be displayed. " + "You can drag select a range of tracks or use CTRL+Click to select specific ones. " + - "The map is updated live in the background. Open the URLs by double clicking them.")), + "The map is updated live in the background. Open the URLs by double clicking them, " + + "edit name and description by double clicking the cell.")), GBC.eop().fill(GBC.HORIZONTAL)); // build table final boolean[] trackVisibilityBackup = layer.trackVisibility.clone(); - table = buildTable(buildTableContents()); + Object[][] content = buildTableContents(); + table = buildTable(content); selectVisibleTracksInTable(); listenToSelectionChanges(); @@ -263,7 +360,24 @@ int v = 1; // build dialog - ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(), tr("Set track visibility for {0}", layer.getName()), - tr("Show all"), tr("Show selected only"), tr("Cancel")); - ed.setButtonIcons("eye", "dialogs/filter", "cancel"); + ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(), + tr("Set track visibility for {0}", layer.getName()), + tr("Set color for selected tracks..."), tr("Show all"), tr("Show selected only"), tr("Close")) { + @Override + protected void buttonAction(int buttonIndex, ActionEvent evt) { + if (buttonIndex == 0) { + List trks = new ArrayList<>(); + for (int i : table.getSelectedRows()) { + Object trk = content[i][5]; + if (trk != null && trk instanceof GpxTrack) { + trks.add((GpxTrack) trk); + } + } + showColorDialog(trks); + } else { + super.buttonAction(buttonIndex, evt); + } + } + }; + ed.setButtonIcons("colorchooser", "eye", "dialogs/filter", "cancel"); ed.setContent(msg, false); ed.setDefaultButton(2); @@ -276,13 +390,13 @@ v = ed.getValue(); // cancel for unknown buttons and copy back original settings - if (v != 1 && v != 2) { + if (v != 2 && v != 3) { layer.trackVisibility = Arrays.copyOf(trackVisibilityBackup, layer.trackVisibility.length); MainApplication.getMap().repaint(); return; } - // set visibility (1 = show all, 2 = filter). If no tracks are selected + // set visibility (2 = show all, 3 = filter). If no tracks are selected // set all of them visible and... ListSelectionModel s = table.getSelectionModel(); - final boolean all = v == 1 || s.isSelectionEmpty(); + final boolean all = v == 2 || s.isSelectionEmpty(); for (int i = 0; i < layer.trackVisibility.length; i++) { layer.trackVisibility[table.convertRowIndexToModel(i)] = all || s.isSelectedIndex(i); @@ -291,5 +405,5 @@ layer.invalidate(); // ...sync with layer visibility instead to avoid having two ways to hide everything - layer.setVisible(v == 1 || !s.isSelectionEmpty()); + layer.setVisible(v == 2 || !s.isSelectionEmpty()); } } Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertFromGpxLayerAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertFromGpxLayerAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertFromGpxLayerAction.java (revision 15496) @@ -8,7 +8,7 @@ import java.awt.event.ActionListener; import java.util.ArrayList; -import java.util.Collection; import java.util.Date; import java.util.List; +import java.util.Map; import java.util.Map.Entry; @@ -21,9 +21,12 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; -import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.GpxExtension; +import org.openstreetmap.josm.data.gpx.GpxExtensionCollection; +import org.openstreetmap.josm.data.gpx.IGpxTrack; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.DataSet; import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.Way; import org.openstreetmap.josm.gui.ExtendedDialog; @@ -54,4 +57,5 @@ public DataSet convert() { final DataSet ds = new DataSet(); + ds.setGPXNamespaces(layer.data.getNamespaces()); List keys = new ArrayList<>(); // note that items in this list don't have the GPX_PREFIX @@ -60,26 +64,12 @@ boolean none = "no".equals(convertTags); // no need to convert tags when no dialog will be shown anyways - for (GpxTrack trk : layer.data.getTracks()) { - for (GpxTrackSegment segment : trk.getSegments()) { + for (IGpxTrack trk : layer.data.getTracks()) { + for (IGpxTrackSegment segment : trk.getSegments()) { List nodes = new ArrayList<>(); for (WayPoint p : segment.getWayPoints()) { Node n = new Node(p.getCoor()); - for (Entry entry : p.attr.entrySet()) { - String key = entry.getKey(); - Object obj = p.get(key); - if (check && !keys.contains(key) && (obj instanceof String || obj instanceof Number || obj instanceof Date)) { - keys.add(key); - } - if (!none && (obj instanceof String || obj instanceof Number)) { - // only convert when required - n.put(GpxConstants.GPX_PREFIX + key, obj.toString()); - } else if (obj instanceof Date && GpxConstants.PT_TIME.equals(key)) { - // timestamps should always be converted - Date date = (Date) obj; - if (!none) { //... but the tag will only be set when required - n.put(GpxConstants.GPX_PREFIX + key, DateUtils.fromDate(date)); - } - n.setTimestamp(date); - } + addAttributes(p.getAttributes(), n, keys, check, none); + if (!none) { + addExtensions(p.getExtensions(), n, false, keys, check); } ds.addPrimitive(n); @@ -88,4 +78,10 @@ Way w = new Way(); w.setNodes(nodes); + addAttributes(trk.getAttributes(), w, keys, check, none); + addAttributes(segment.getAttributes(), w, keys, check, none); + if (!none) { + addExtensions(trk.getExtensions(), w, false, keys, check); + addExtensions(segment.getExtensions(), w, true, keys, check); + } ds.addPrimitive(w); } @@ -123,4 +119,49 @@ } + private static void addAttributes(Map attr, OsmPrimitive p, List keys, boolean check, boolean none) { + for (Entry entry : attr.entrySet()) { + String key = entry.getKey(); + Object obj = entry.getValue(); + if (check && !keys.contains(key) && (obj instanceof String || obj instanceof Number || obj instanceof Date)) { + keys.add(key); + } + if (!none && (obj instanceof String || obj instanceof Number)) { + // only convert when required + p.put(GpxConstants.GPX_PREFIX + key, obj.toString()); + } else if (obj instanceof Date && GpxConstants.PT_TIME.equals(key)) { + // timestamps should always be converted + Date date = (Date) obj; + if (!none) { //... but the tag will only be set when required + p.put(GpxConstants.GPX_PREFIX + key, DateUtils.fromDate(date)); + } + p.setTimestamp(date); + } + } + } + + private static void addExtensions(GpxExtensionCollection exts, OsmPrimitive p, boolean seg, List keys, boolean check) { + for (GpxExtension ext : exts) { + String value = ext.getValue(); + if (value != null && !value.isEmpty()) { + String extpre = "extension:"; + String pre = ext.getPrefix(); + if (pre == null || pre.isEmpty()) { + pre = "other"; + } + String segpre = seg ? "segment:" : ""; //needs to be distinguished since both track and segment extensions are applied to the resulting way + String key = ext.getFlatKey(); + String fullkey = GpxConstants.GPX_PREFIX + extpre + pre + ":" + segpre + key; + if (GpxConstants.EXTENSION_ABBREVIATIONS.containsKey(fullkey)) { + fullkey = GpxConstants.EXTENSION_ABBREVIATIONS.get(fullkey); + } + if (check && !keys.contains(fullkey)) { + keys.add(fullkey); + } + p.put(fullkey, value); + } + addExtensions(ext.getExtensions(), p, seg, keys, check); + } + } + /** * Filters the tags of the given {@link DataSet} @@ -131,9 +172,14 @@ */ public DataSet filterDataSet(DataSet ds, List listPos) { - Collection nodes = ds.getNodes(); - for (Node n : nodes) { - for (String key : n.keySet()) { - if (listPos == null || !listPos.contains(key.substring(GpxConstants.GPX_PREFIX.length()))) { - n.put(key, null); + for (OsmPrimitive p : ds.getPrimitives(p -> p instanceof Node || p instanceof Way)) { + for (String key : p.keySet()) { + String listkey; + if (listPos != null && key.startsWith(GpxConstants.GPX_PREFIX)) { + listkey = key.substring(GpxConstants.GPX_PREFIX.length()); + } else { + listkey = key; + } + if (listPos == null || !listPos.contains(listkey)) { + p.put(key, null); } } Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/CustomizeDrawingAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/CustomizeDrawingAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/CustomizeDrawingAction.java (revision 15496) @@ -10,4 +10,5 @@ import java.util.LinkedList; import java.util.List; +import java.util.stream.Collectors; import javax.swing.AbstractAction; @@ -60,10 +61,5 @@ @Override public boolean supportLayers(List layers) { - for (Layer layer : layers) { - if (!(layer instanceof GpxLayer)) { - return false; - } - } - return true; + return layers.stream().allMatch(l -> l instanceof GpxLayer); } @@ -80,16 +76,5 @@ @Override public void actionPerformed(ActionEvent e) { - boolean hasLocal = false; - boolean hasNonlocal = false; - for (Layer layer : layers) { - if (layer instanceof GpxLayer) { - if (((GpxLayer) layer).isLocalFile()) { - hasLocal = true; - } else { - hasNonlocal = true; - } - } - } - GPXSettingsPanel panel = new GPXSettingsPanel(layers.get(0).getName(), hasLocal, hasNonlocal); + GPXSettingsPanel panel = new GPXSettingsPanel(layers.stream().filter(l -> l instanceof GpxLayer).map(l -> (GpxLayer) l).collect(Collectors.toList())); JScrollPane scrollpane = GuiHelper.embedInVerticalScrollPane(panel); scrollpane.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0)); @@ -104,13 +89,7 @@ return; } - for (Layer layer : layers) { - // save preferences for all layers - boolean f = false; - if (layer instanceof GpxLayer) { - f = ((GpxLayer) layer).isLocalFile(); - } - panel.savePreferences(layer.getName(), f); - } - MainApplication.getMap().repaint(); + panel.savePreferences(); + MainApplication.getMainPanel().repaint(); + layers.stream().forEach(Layer::invalidate); } Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongTrackAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongTrackAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongTrackAction.java (revision 15496) @@ -9,5 +9,5 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.gui.PleaseWaitRunnable; @@ -61,5 +61,5 @@ if (near == NEAR_TRACK || near == NEAR_BOTH) { for (GpxTrack trk : data.tracks) { - for (GpxTrackSegment segment : trk.getSegments()) { + for (IGpxTrackSegment segment : trk.getSegments()) { boolean first = true; for (WayPoint p : segment.getWayPoints()) { Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadWmsAlongTrackAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadWmsAlongTrackAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadWmsAlongTrackAction.java (revision 15496) @@ -17,5 +17,5 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.gui.MainApplication; @@ -93,5 +93,5 @@ List points = new ArrayList<>(); for (GpxTrack trk : data.tracks) { - for (GpxTrackSegment segment : trk.getSegments()) { + for (IGpxTrackSegment segment : trk.getSegments()) { for (WayPoint p : segment.getWayPoints()) { points.add(p.getCoor()); Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java (revision 15496) @@ -28,4 +28,5 @@ import java.util.LinkedList; import java.util.List; +import java.util.Objects; import java.util.Random; @@ -33,5 +34,4 @@ import org.openstreetmap.josm.data.Bounds; -import org.openstreetmap.josm.data.PreferencesUtils; import org.openstreetmap.josm.data.SystemOfMeasurement; import org.openstreetmap.josm.data.SystemOfMeasurement.SoMChangeListener; @@ -52,4 +52,5 @@ import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationEvent; import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationListener; +import org.openstreetmap.josm.gui.preferences.display.GPXSettingsPanel; import org.openstreetmap.josm.io.CachedFile; import org.openstreetmap.josm.spi.preferences.Config; @@ -66,8 +67,8 @@ /** - * The color that is used for drawing GPX points. - * @since 10824 - */ - public static final NamedColorProperty DEFAULT_COLOR = new NamedColorProperty(marktr("gps point"), Color.magenta); + * The default color property that is used for drawing GPX points. + * @since 15496 + */ + public static final NamedColorProperty DEFAULT_COLOR_PROPERTY = new NamedColorProperty(marktr("gps point"), Color.magenta); private final GpxData data; @@ -79,5 +80,5 @@ private boolean alphaLines; // draw direction arrows on the lines - private boolean direction; + private boolean arrows; /** width of line for paint **/ private int lineWidth; @@ -91,7 +92,7 @@ private boolean hdopCircle; /** paint direction arrow with alternate math. may be faster **/ - private boolean alternateDirection; + private boolean arrowsFast; /** don't draw arrows nearer to each other than this **/ - private int delta; + private int arrowsDelta; private double minTrackDurationForTimeColoring; @@ -107,5 +108,5 @@ private boolean computeCacheColorDynamic; private ColorMode computeCacheColored; - private int computeCacheColorTracksTune; + private int computeCacheVelocityTune; private int computeCacheHeatMapDrawColorTableIdx; private boolean computeCacheHeatMapDrawPointMode; @@ -113,9 +114,12 @@ private int computeCacheHeatMapDrawLowerLimit; + private Color colorCache; + private Color colorCacheTransparent; + //// Color-related fields /** Mode of the line coloring **/ private ColorMode colored; /** max speed for coloring - allows to tweak line coloring for different speed levels. **/ - private int colorTracksTune; + private int velocityTune; private boolean colorModeDynamic; private Color neutralColor; @@ -146,6 +150,4 @@ /** heat map parameters **/ - // enabled or not (override by settings) - private boolean heatMapEnabled; // draw small extra line private boolean heatMapDrawExtraLine; @@ -269,33 +271,12 @@ } - private static String specName(String layerName) { - return "layer " + layerName; - } - - /** - * Get the default color for gps tracks for specified layer - * @param layerName name of the GpxLayer - * @param ignoreCustom do not use preferences - * @return the color or null if the color is not constant - */ - public Color getColor(String layerName, boolean ignoreCustom) { - if (ignoreCustom || getColorMode(layerName) == ColorMode.NONE) { - return DEFAULT_COLOR.getChildColor( - NamedColorProperty.COLOR_CATEGORY_LAYER, - layerName, - DEFAULT_COLOR.getName()).get(); - } else { - return null; - } - } - /** * Read coloring mode for specified layer from preferences - * @param layerName name of the GpxLayer * @return coloring mode */ - public ColorMode getColorMode(String layerName) { + public ColorMode getColorMode() { try { - int i = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.colors", specName(layerName), 0); + int i = optInt("colormode"); + if (i == -1) i = 0; //global return ColorMode.fromIndex(i); } catch (IndexOutOfBoundsException e) { @@ -305,54 +286,56 @@ } - /** Reads generic color from preferences (usually gray) - * @return the color + private String opt(String key) { + return GPXSettingsPanel.getLayerPref(layer, key); + } + + private boolean optBool(String key) { + return Boolean.parseBoolean(opt(key)); + } + + private int optInt(String key) { + return GPXSettingsPanel.getLayerPrefInt(layer, key); + } + + /** + * Read all drawing-related settings from preferences **/ - public static Color getGenericColor() { - return DEFAULT_COLOR.get(); - } - - /** - * Read all drawing-related settings from preferences - * @param layerName layer name used to access its specific preferences - **/ - public void readPreferences(String layerName) { - String spec = specName(layerName); - forceLines = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines.force", spec, false); - direction = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.direction", spec, false); - lineWidth = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.linewidth", spec, 0); - alphaLines = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines.alpha-blend", spec, false); - + public void readPreferences() { + forceLines = optBool("lines.force"); + arrows = optBool("lines.arrows"); + arrowsFast = optBool("lines.arrows.fast"); + arrowsDelta = optInt("lines.arrows.min-distance"); + lineWidth = optInt("lines.width"); + alphaLines = optBool("lines.alpha-blend"); + + int l = optInt("lines"); if (!data.fromServer) { - maxLineLength = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.max-line-length.local", spec, -1); - lines = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines.local", spec, true); + maxLineLength = optInt("lines.max-length.local"); + lines = l != 0; //draw for -1 (default), 1 (local) and 2 (all) } else { - maxLineLength = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.max-line-length", spec, 200); - lines = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines", spec, true); - } - large = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.large", spec, false); - largesize = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.large.size", spec, 3); - hdopCircle = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.hdopcircle", spec, false); - colored = getColorMode(layerName); - alternateDirection = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.alternatedirection", spec, false); - delta = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.min-arrow-distance", spec, 40); - colorTracksTune = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.colorTracksTune", spec, 45); - colorModeDynamic = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.colors.dynamic", spec, false); + maxLineLength = optInt("lines.max-length"); + lines = l == 2; //draw only for 2 (all) + } + large = optBool("points.large"); + largesize = optInt("points.large.size"); + hdopCircle = optBool("points.hdopcircle"); + colored = getColorMode(); + velocityTune = optInt("colormode.velocity.tune"); + colorModeDynamic = optBool("colormode.dynamic-range"); /* good HDOP's are between 1 and 3, very bad HDOP's go into 3 digit values */ hdoprange = Config.getPref().getInt("hdop.range", 7); - minTrackDurationForTimeColoring = Config.getPref().getInt("draw.rawgps.date-coloring-min-dt", 60); - largePointAlpha = Config.getPref().getInt("draw.rawgps.large.alpha", -1) & 0xFF; + minTrackDurationForTimeColoring = optInt("colormode.time.min-distance"); + largePointAlpha = optInt("points.large.alpha") & 0xFF; // get heatmap parameters - heatMapEnabled = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.heatmap.enabled", spec, false); - heatMapDrawExtraLine = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.heatmap.line-extra", spec, false); - heatMapDrawColorTableIdx = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.heatmap.colormap", spec, 0); - heatMapDrawPointMode = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.heatmap.use-points", spec, false); - heatMapDrawGain = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.heatmap.gain", spec, 0); - heatMapDrawLowerLimit = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.heatmap.lower-limit", spec, 0); + heatMapDrawExtraLine = optBool("colormode.heatmap.line-extra"); + heatMapDrawColorTableIdx = optInt("colormode.heatmap.colormap"); + heatMapDrawPointMode = optBool("colormode.heatmap.use-points"); + heatMapDrawGain = optInt("colormode.heatmap.gain"); + heatMapDrawLowerLimit = optInt("colormode.heatmap.lower-limit"); // shrink to range heatMapDrawGain = Utils.clamp(heatMapDrawGain, -10, 10); - - neutralColor = getColor(layerName, true); + neutralColor = DEFAULT_COLOR_PROPERTY.get(); velocityScale.setNoDataColor(neutralColor); dateScale.setNoDataColor(neutralColor); @@ -369,5 +352,5 @@ List visibleSegments = listVisibleSegments(clipBounds); if (!visibleSegments.isEmpty()) { - readPreferences(layer.getName()); + readPreferences(); drawAll(graphics.getDefaultGraphics(), graphics.getMapView(), visibleSegments, clipBounds); if (graphics.getMapView().getLayerManager().getActiveLayer() == layer) { @@ -431,5 +414,4 @@ * @since 14748 : new parameter clipBounds */ - public void drawAll(Graphics2D g, MapView mv, List visibleSegments, Bounds clipBounds) { @@ -463,5 +445,5 @@ // global enabled or select via color - boolean useHeatMap = heatMapEnabled || ColorMode.HEATMAP == colored; + boolean useHeatMap = ColorMode.HEATMAP == colored; // default global alpha level @@ -571,5 +553,5 @@ oldWp = null; } else { // color mode not dynamic - velocityScale.setRange(0, colorTracksTune); + velocityScale.setRange(0, velocityTune); hdopScale.setRange(0, hdoprange); qualityScale.setRange(1, rtkLibQualityColors.length); @@ -595,5 +577,5 @@ for (WayPoint trkPnt : segment) { LatLon c = trkPnt.getCoor(); - trkPnt.customColoring = neutralColor; + trkPnt.customColoring = segment.getColor(); if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) { continue; @@ -643,5 +625,5 @@ } else { // make sure we reset outdated data trkPnt.drawLine = false; - color = neutralColor; + color = segment.getColor(); } if (color != null) { @@ -701,5 +683,5 @@ ********** STEP 3b - DRAW NICE ARROWS ************************** ****************************************************************/ - if (lines && direction && !alternateDirection) { + if (lines && arrows && !arrowsFast) { Point old = null; Point oldA = null; // last arrow painted @@ -713,6 +695,6 @@ // skip points that are on the same screenposition if (old != null - && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta - || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) { + && (oldA == null || screen.x < oldA.x - arrowsDelta || screen.x > oldA.x + arrowsDelta + || screen.y < oldA.y - arrowsDelta || screen.y > oldA.y + arrowsDelta)) { g.setColor(trkPnt.customColoring); double t = Math.atan2((double) screen.y - old.y, (double) screen.x - old.x) + Math.PI; @@ -731,5 +713,5 @@ ********** STEP 3c - DRAW FAST ARROWS ************************** ****************************************************************/ - if (lines && direction && alternateDirection) { + if (lines && arrows && arrowsFast) { Point old = null; Point oldA = null; // last arrow painted @@ -743,6 +725,6 @@ // skip points that are on the same screenposition if (old != null - && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta - || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) { + && (oldA == null || screen.x < oldA.x - arrowsDelta || screen.x > oldA.x + arrowsDelta + || screen.y < oldA.y - arrowsDelta || screen.y > oldA.y + arrowsDelta)) { g.setColor(trkPnt.customColoring); g.drawLine(screen.x, screen.y, screen.x + dir[trkPnt.dir][0], screen.y @@ -795,8 +777,14 @@ // color the large GPS points like the gps lines if (trkPnt.customColoring != null) { - Color customColoringTransparent = largePointAlpha < 0 ? trkPnt.customColoring : - new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (largePointAlpha << 24), true); - - g.setColor(customColoringTransparent); + if (trkPnt.customColoring.equals(colorCache) && colorCacheTransparent != null) { + g.setColor(colorCacheTransparent); + } else { + Color customColoringTransparent = largePointAlpha < 0 ? trkPnt.customColoring : + new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (largePointAlpha << 24), true); + + g.setColor(customColoringTransparent); + colorCache = trkPnt.customColoring; + colorCacheTransparent = customColoringTransparent; + } } g.fillRect(screen.x-halfSize, screen.y-halfSize, largesize, largesize); @@ -816,4 +804,5 @@ } if (!trkPnt.drawLine) { + g.setColor(trkPnt.customColoring); Point screen = mv.getPoint(trkPnt); g.drawRect(screen.x, screen.y, 0, 0); @@ -1481,10 +1470,10 @@ if ((computeCacheMaxLineLengthUsed != maxLineLength) || (computeCacheColored != colored) - || (computeCacheColorTracksTune != colorTracksTune) + || (computeCacheVelocityTune != velocityTune) || (computeCacheColorDynamic != colorModeDynamic) || (computeCacheHeatMapDrawColorTableIdx != heatMapDrawColorTableIdx) - || (!neutralColor.equals(computeCacheColorUsed) + || !Objects.equals(neutralColor, computeCacheColorUsed) || (computeCacheHeatMapDrawPointMode != heatMapDrawPointMode) - || (computeCacheHeatMapDrawGain != heatMapDrawGain)) + || (computeCacheHeatMapDrawGain != heatMapDrawGain) || (computeCacheHeatMapDrawLowerLimit != heatMapDrawLowerLimit) ) { @@ -1494,5 +1483,5 @@ computeCacheColorUsed = neutralColor; computeCacheColored = colored; - computeCacheColorTracksTune = colorTracksTune; + computeCacheVelocityTune = velocityTune; computeCacheColorDynamic = colorModeDynamic; computeCacheHeatMapDrawColorTableIdx = heatMapDrawColorTableIdx; Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java (revision 15496) @@ -22,5 +22,5 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.projection.ProjectionRegistry; @@ -148,5 +148,5 @@ if (hasTracks) { for (GpxTrack track : layer.data.tracks) { - for (GpxTrackSegment seg : track.getSegments()) { + for (IGpxTrackSegment seg : track.getSegments()) { for (WayPoint w : seg.getWayPoints()) { firstTime = w.getTime(); @@ -207,5 +207,5 @@ && !layer.data.tracks.isEmpty()) { for (GpxTrack track : layer.data.tracks) { - for (GpxTrackSegment seg : track.getSegments()) { + for (IGpxTrackSegment seg : track.getSegments()) { for (WayPoint w : seg.getWayPoints()) { if (w.attr.containsKey(GpxConstants.GPX_NAME) || w.attr.containsKey(GpxConstants.GPX_DESC)) { @@ -228,5 +228,5 @@ for (GpxTrack track : layer.data.tracks) { - for (GpxTrackSegment seg : track.getSegments()) { + for (IGpxTrackSegment seg : track.getSegments()) { for (WayPoint w : seg.getWayPoints()) { if (startTime < w.getTime()) { @@ -264,5 +264,5 @@ boolean gotOne = false; for (GpxTrack track : layer.data.tracks) { - for (GpxTrackSegment seg : track.getSegments()) { + for (IGpxTrackSegment seg : track.getSegments()) { for (WayPoint w : seg.getWayPoints()) { WayPoint wStart = new WayPoint(w.getCoor()); Index: /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarker.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarker.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarker.java (revision 15496) @@ -94,6 +94,6 @@ @Override - protected TemplateEntryProperty getTextTemplate() { - return TemplateEntryProperty.forAudioMarker(parentLayer.getName()); + protected String getTextTemplateKey() { + return "markers.audio.pattern"; } @@ -104,6 +104,6 @@ link.type = "audio"; wpt.put(GpxConstants.META_LINKS, Collections.singleton(link)); - wpt.addExtension("offset", Double.toString(offset)); - wpt.addExtension("sync-offset", Double.toString(syncOffset)); + wpt.getExtensions().add("josm", "offset", Double.toString(offset)); + wpt.getExtensions().add("josm", "sync-offset", Double.toString(syncOffset)); return wpt; } Index: /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/DefaultMarkerProducers.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/DefaultMarkerProducers.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/DefaultMarkerProducers.java (revision 15496) @@ -10,6 +10,6 @@ import java.util.Optional; -import org.openstreetmap.josm.data.gpx.Extensions; import org.openstreetmap.josm.data.gpx.GpxConstants; +import org.openstreetmap.josm.data.gpx.GpxExtension; import org.openstreetmap.josm.data.gpx.GpxLink; import org.openstreetmap.josm.data.gpx.WayPoint; @@ -46,8 +46,8 @@ } else if (Utils.hasExtension(urlStr, "wav", "mp3", "aac", "aif", "aiff")) { final AudioMarker audioMarker = new AudioMarker(wpt.getCoor(), wpt, url, parentLayer, time, offset); - Extensions exts = (Extensions) wpt.get(GpxConstants.META_EXTENSIONS); - if (exts != null && exts.containsKey("offset")) { + GpxExtension offsetExt = wpt.getExtensions().get("josm", "sync-offset"); + if (offsetExt != null && offsetExt.getValue() != null) { try { - audioMarker.syncOffset = Double.parseDouble(exts.get("sync-offset")); + audioMarker.syncOffset = Double.parseDouble(offsetExt.getValue()); } catch (NumberFormatException nfe) { Logging.warn(nfe); Index: /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java (revision 15496) @@ -19,4 +19,5 @@ import javax.swing.ImageIcon; +import org.openstreetmap.josm.data.Preferences; import org.openstreetmap.josm.data.coor.CachedLatLon; import org.openstreetmap.josm.data.coor.EastNorth; @@ -26,7 +27,7 @@ import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.search.SearchCompiler.Match; -import org.openstreetmap.josm.data.preferences.CachedProperty; import org.openstreetmap.josm.gui.MapView; -import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent; +import org.openstreetmap.josm.gui.layer.GpxLayer; +import org.openstreetmap.josm.gui.preferences.display.GPXSettingsPanel; import org.openstreetmap.josm.tools.ImageProvider; import org.openstreetmap.josm.tools.Logging; @@ -73,78 +74,4 @@ public class Marker implements TemplateEngineDataProvider, ILatLon { - public static final class TemplateEntryProperty extends CachedProperty { - // This class is a bit complicated because it supports both global and per layer settings. I've added per layer settings because - // GPXSettingsPanel had possibility to set waypoint label but then I've realized that markers use different layer then gpx data - // so per layer settings is useless. Anyway it's possible to specify marker layer pattern in Einstein preferences and maybe somebody - // will make gui for it so I'm keeping it here - - private static final Map CACHE = new HashMap<>(); - - public static TemplateEntryProperty forMarker(String layerName) { - String key = "draw.rawgps.layer.wpt.pattern"; - if (layerName != null) { - key += '.' + layerName; - } - TemplateEntryProperty result = CACHE.get(key); - if (result == null) { - String defaultValue = layerName == null ? LABEL_PATTERN_AUTO : ""; - TemplateEntryProperty parent = layerName == null ? null : forMarker(null); - result = new TemplateEntryProperty(key, defaultValue, parent); - CACHE.put(key, result); - } - return result; - } - - public static TemplateEntryProperty forAudioMarker(String layerName) { - String key = "draw.rawgps.layer.audiowpt.pattern"; - if (layerName != null) { - key += '.' + layerName; - } - TemplateEntryProperty result = CACHE.get(key); - if (result == null) { - String defaultValue = layerName == null ? "?{ '{name}' | '{desc}' | '{" + Marker.MARKER_FORMATTED_OFFSET + "}' }" : ""; - TemplateEntryProperty parent = layerName == null ? null : forAudioMarker(null); - result = new TemplateEntryProperty(key, defaultValue, parent); - CACHE.put(key, result); - } - return result; - } - - private final TemplateEntryProperty parent; - - private TemplateEntryProperty(String key, String defaultValue, TemplateEntryProperty parent) { - super(key, defaultValue); - this.parent = parent; - updateValue(); // Needs to be called because parent wasn't know in super constructor - } - - @Override - protected TemplateEntry fromString(String s) { - try { - return new TemplateParser(s).parse(); - } catch (ParseError e) { - Logging.debug(e); - Logging.warn("Unable to parse template engine pattern ''{0}'' for property {1}. Using default (''{2}'') instead", - s, getKey(), super.getDefaultValueAsString()); - return getDefaultValue(); - } - } - - @Override - public String getDefaultValueAsString() { - if (parent == null) - return super.getDefaultValueAsString(); - else - return parent.getAsString(); - } - - @Override - public void preferenceChanged(PreferenceChangeEvent e) { - if (e.getKey().equals(key) || (parent != null && e.getKey().equals(parent.getKey()))) { - updateValue(); - } - } - } - /** * Plugins can add their Marker creation stuff at the bottom or top of this list @@ -217,5 +144,7 @@ private String cachedText; - private int textVersion = -1; + private static Map cachedTemplates = new HashMap<>(); + private String cachedDefaultTemplate; + private CachedLatLon coor; @@ -245,4 +174,6 @@ this.dataProvider = dataProvider; this.text = text; + + Preferences.main().addKeyPreferenceChangeListener("draw.rawgps." + getTextTemplateKey(), l -> updateText()); } @@ -258,5 +189,5 @@ wpt.setTimeInMillis((long) (time * 1000)); if (text != null) { - wpt.addExtension("text", text); + wpt.getExtensions().add("josm", "text", text); } else if (dataProvider != null) { for (String key : dataProvider.getTemplateKeys()) { @@ -373,6 +304,24 @@ } - protected TemplateEntryProperty getTextTemplate() { - return TemplateEntryProperty.forMarker(parentLayer.getName()); + protected String getTextTemplateKey() { + return "markers.pattern"; + } + + private String getTextTemplate() { + String tmpl; + if (cachedTemplates.containsKey(parentLayer.fromLayer)) { + tmpl = cachedTemplates.get(parentLayer.fromLayer); + } else { + tmpl = GPXSettingsPanel.getLayerPref(parentLayer.fromLayer, getTextTemplateKey()); + cachedTemplates.put(parentLayer.fromLayer, tmpl); + } + return tmpl; + } + + private String getDefaultTextTemplate() { + if (cachedDefaultTemplate == null) { + cachedDefaultTemplate = GPXSettingsPanel.getLayerPref(null, getTextTemplateKey()); + } + return cachedDefaultTemplate; } @@ -382,18 +331,39 @@ */ public String getText() { - if (text != null) + if (text != null) { return text; - else { - TemplateEntryProperty property = getTextTemplate(); - if (property.getUpdateCount() != textVersion) { - TemplateEntry templateEntry = property.get(); - StringBuilder sb = new StringBuilder(); - templateEntry.appendText(sb, this); - - cachedText = sb.toString(); - textVersion = property.getUpdateCount(); + } else if (cachedText == null) { + TemplateEntry template; + String templateString = getTextTemplate(); + try { + template = new TemplateParser(templateString).parse(); + } catch (ParseError e) { + Logging.debug(e); + String def = getDefaultTextTemplate(); + Logging.warn("Unable to parse template engine pattern ''{0}'' for property {1}. Using default (''{2}'') instead", + templateString, getTextTemplateKey(), def); + try { + template = new TemplateParser(def).parse(); + } catch (ParseError e1) { + Logging.error(e1); + cachedText = ""; + return ""; + } } - return cachedText; - } + StringBuilder sb = new StringBuilder(); + template.appendText(sb, this); + cachedText = sb.toString(); + + } + return cachedText; + } + + /** + * Called when the template changes + */ + public void updateText() { + cachedText = null; + cachedDefaultTemplate = null; + cachedTemplates = new HashMap<>(); } Index: /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java (revision 15496) @@ -21,4 +21,5 @@ import java.util.Comparator; import java.util.List; +import java.util.Optional; import javax.swing.AbstractAction; @@ -31,7 +32,7 @@ import org.openstreetmap.josm.data.Bounds; import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.data.gpx.Extensions; import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxExtension; import org.openstreetmap.josm.data.gpx.GpxLink; import org.openstreetmap.josm.data.gpx.WayPoint; @@ -49,4 +50,5 @@ import org.openstreetmap.josm.gui.layer.Layer; import org.openstreetmap.josm.gui.layer.gpx.ConvertFromMarkerLayerAction; +import org.openstreetmap.josm.gui.preferences.display.GPXSettingsPanel; import org.openstreetmap.josm.io.audio.AudioPlayer; import org.openstreetmap.josm.spi.preferences.Config; @@ -76,7 +78,10 @@ private Marker currentMarker; public AudioMarker syncAudioMarker; - - private static final Color DEFAULT_COLOR = Color.magenta; - private static final NamedColorProperty COLOR_PROPERTY = new NamedColorProperty(marktr("gps marker"), DEFAULT_COLOR); + private Color color, realcolor; + + /** + * The default color that is used for drawing markers. + */ + public static final NamedColorProperty DEFAULT_COLOR_PROPERTY = new NamedColorProperty(marktr("gps marker"), Color.magenta); /** @@ -95,4 +100,15 @@ String lastLinkedFile = ""; + Color c = null; + String cs = GPXSettingsPanel.tryGetLayerPrefLocal(indata, "markers.color"); + if (cs != null) { + try { + c = Color.decode(cs); + } catch (NumberFormatException ex) { + Logging.warn("Could not read marker color: " + cs); + } + } + setPrivateColors(c); + for (WayPoint wpt : indata.waypoints) { /* calculate time differences in waypoints */ @@ -124,8 +140,8 @@ // that group. This way the user can jump to the corresponding // playback positions in a long audio track. - Extensions exts = (Extensions) wpt.get(GpxConstants.META_EXTENSIONS); - if (exts != null && exts.containsKey("offset")) { + GpxExtension offsetExt = wpt.getExtensions().get("josm", "offset"); + if (offsetExt != null && offsetExt.getValue() != null) { try { - offset = Double.valueOf(exts.get("offset")); + offset = Double.valueOf(offsetExt.getValue()); } catch (NumberFormatException nfe) { Logging.warn(nfe); @@ -174,18 +190,7 @@ @Override - protected NamedColorProperty getBaseColorProperty() { - return COLOR_PROPERTY; - } - - /* for preferences */ - public static Color getGenericColor() { - return COLOR_PROPERTY.get(); - } - - @Override public void paint(Graphics2D g, MapView mv, Bounds box) { boolean showTextOrIcon = isTextOrIconShown(); - g.setColor(getColorProperty().get()); - + g.setColor(realcolor); if (mousePressed) { boolean mousePressedTmp = mousePressed; @@ -451,6 +456,33 @@ */ private boolean isTextOrIconShown() { - String current = Config.getPref().get("marker.show "+getName(), "show"); - return "show".equalsIgnoreCase(current); + return Boolean.parseBoolean(GPXSettingsPanel.getLayerPref(fromLayer, "markers.show-text")); + } + + @Override + public boolean hasColor() { + return true; + } + + @Override + public Color getColor() { + return color; + } + + @Override + public void setColor(Color color) { + setPrivateColors(color); + if (fromLayer != null) { + String cs = null; + if (color != null) { + cs = String.format("#%02X%02X%02X", color.getRed(), color.getGreen(), color.getBlue()); + } + GPXSettingsPanel.putLayerPrefLocal(fromLayer, "markers.color", cs); + } + invalidate(); + } + + private void setPrivateColors(Color color) { + this.color = color; + this.realcolor = Optional.ofNullable(color).orElse(DEFAULT_COLOR_PROPERTY.get()); } @@ -504,5 +536,5 @@ @Override public void actionPerformed(ActionEvent e) { - Config.getPref().put("marker.show "+layer.getName(), layer.isTextOrIconShown() ? "hide" : "show"); + GPXSettingsPanel.putLayerPrefLocal(layer.fromLayer, "markers.show-text", Boolean.toString(!layer.isTextOrIconShown())); layer.invalidate(); } Index: /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java (revision 15496) @@ -19,5 +19,5 @@ import org.openstreetmap.josm.data.coor.LatLon; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.projection.ProjectionRegistry; @@ -328,5 +328,5 @@ for (GpxTrack track : trackLayer.data.getTracks()) { - for (GpxTrackSegment trackseg : track.getSegments()) { + for (IGpxTrackSegment trackseg : track.getSegments()) { for (WayPoint w: trackseg.getWayPoints()) { if (audioTime < w.getTime()) { Index: /trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java (revision 15496) @@ -101,17 +101,4 @@ public String getDisplay() { switch (info.getCategory()) { - case NamedColorProperty.COLOR_CATEGORY_LAYER: - String v = null; - if (info.getSource() != null) { - v = info.getSource(); - } - if (!info.getName().isEmpty()) { - if (v == null) { - v = tr(I18n.escape(info.getName())); - } else { - v += " - " + tr(I18n.escape(info.getName())); - } - } - return tr("Layer: {0}", v); case NamedColorProperty.COLOR_CATEGORY_MAPPAINT: if (info.getSource() != null) @@ -252,6 +239,5 @@ case NamedColorProperty.COLOR_CATEGORY_GENERAL: return 1; case NamedColorProperty.COLOR_CATEGORY_MAPPAINT: return 2; - case NamedColorProperty.COLOR_CATEGORY_LAYER: return 3; - default: return 4; + default: return 3; } } @@ -380,6 +366,10 @@ } + @SuppressWarnings("PMD.UnusedFormalParameter") private static boolean isRemoveColor(ColorEntry ce) { - return NamedColorProperty.COLOR_CATEGORY_LAYER.equals(ce.info.getCategory()); + return false; + //COLOR_CATEGORY_LAYER is no longer supported and was the only one that could be removed. + //Maybe this is useful for other categories in the future. + //return NamedColorProperty.COLOR_CATEGORY_LAYER.equals(ce.info.getCategory()); } @@ -391,6 +381,6 @@ ConflictColors.getColors(); Severity.getColors(); - MarkerLayer.getGenericColor(); - GpxDrawHelper.getGenericColor(); + MarkerLayer.DEFAULT_COLOR_PROPERTY.get(); + GpxDrawHelper.DEFAULT_COLOR_PROPERTY.get(); OsmDataLayer.getOutsideColor(); MapScaler.getColor(); Index: /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java (revision 15496) @@ -5,10 +5,14 @@ import static org.openstreetmap.josm.tools.I18n.trc; -import java.awt.Color; import java.awt.Component; import java.awt.Dimension; import java.awt.GridBagLayout; import java.awt.event.ActionListener; +import java.util.Collections; import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; import javax.swing.AbstractButton; @@ -23,11 +27,11 @@ import javax.swing.JSlider; +import org.apache.commons.jcs.access.exception.InvalidArgumentException; import org.openstreetmap.josm.actions.ExpertToggleAction; -import org.openstreetmap.josm.data.PreferencesUtils; -import org.openstreetmap.josm.data.preferences.NamedColorProperty; +import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.gui.MainApplication; +import org.openstreetmap.josm.gui.layer.GpxLayer; import org.openstreetmap.josm.gui.layer.gpx.GpxDrawHelper; import org.openstreetmap.josm.gui.layer.markerlayer.Marker; -import org.openstreetmap.josm.gui.layer.markerlayer.Marker.TemplateEntryProperty; import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane.ValidationListener; import org.openstreetmap.josm.gui.widgets.JosmComboBox; @@ -68,5 +72,5 @@ private final JRadioButton colorTypeTime = new JRadioButton(tr("Track date")); private final JRadioButton colorTypeHeatMap = new JRadioButton(tr("Heat Map (dark = few, bright = many)")); - private final JRadioButton colorTypeNone = new JRadioButton(tr("Single Color (can be customized for named layers)")); + private final JRadioButton colorTypeNone = new JRadioButton(tr("Single Color (can be customized in the layer manager)")); private final JRadioButton colorTypeGlobal = new JRadioButton(tr("Use global settings")); private final JosmComboBox colorTypeVelocityTune = new JosmComboBox<>(new String[] {tr("Car"), tr("Bicycle"), tr("Foot")}); @@ -94,19 +98,57 @@ private final JCheckBox drawLineWithAlpha = new JCheckBox(tr("Draw with Opacity (alpha blending) ")); - private String layerName; - private final boolean local; // flag to display LocalOnly checkbox - private final boolean nonlocal; // flag to display AllLines checkbox - - /** - * Constructs a new {@code GPXSettingsPanel} for a given layer name. - * @param layerName The GPX layer name - * @param local flag to display LocalOnly checkbox - * @param nonlocal flag to display AllLines checkbox - */ - public GPXSettingsPanel(String layerName, boolean local, boolean nonlocal) { + private final List layers; + private final GpxLayer firstLayer; + private final boolean global; // global settings vs. layer specific settings + private final boolean hasLocalFile; // flag to display LocalOnly checkbooks + private final boolean hasNonLocalFile; // flag to display AllLines checkbox + + private final static Map DEFAULT_PREFS = getDefaultPrefs(); + + private static Map getDefaultPrefs() { + HashMap m = new HashMap<>(); + m.put("colormode", -1); + m.put("colormode.dynamic-range", false); + m.put("colormode.heatmap.colormap", 0); + m.put("colormode.heatmap.gain", 0); + m.put("colormode.heatmap.line-extra", false); //Einstein only + m.put("colormode.heatmap.lower-limit", 0); + m.put("colormode.heatmap.use-points", false); + m.put("colormode.time.min-distance", 60); //Einstein only + m.put("colormode.velocity.tune", 45); + m.put("lines", -1); + m.put("lines.alpha-blend", false); + m.put("lines.arrows", false); + m.put("lines.arrows.fast", false); + m.put("lines.arrows.min-distance", 40); + m.put("lines.force", false); + m.put("lines.max-length", 200); + m.put("lines.max-length.local", -1); + m.put("lines.width", 0); + m.put("markers.color", ""); + m.put("markers.show-text", true); + m.put("markers.pattern", Marker.LABEL_PATTERN_AUTO); + m.put("markers.audio.pattern", "?{ '{name}' | '{desc}' | '{" + Marker.MARKER_FORMATTED_OFFSET + "}' }"); + m.put("points.hdopcircle", false); + m.put("points.large", false); + m.put("points.large.alpha", -1); //Einstein only + m.put("points.large.size", 3); //Einstein only + return Collections.unmodifiableMap(m); + } + + /** + * Constructs a new {@code GPXSettingsPanel} for the given layers. + * @param layers the GPX layers + */ + public GPXSettingsPanel(List layers) { super(new GridBagLayout()); - this.local = local; - this.nonlocal = nonlocal; - this.layerName = "layer "+layerName; + this.layers = layers; + if (layers == null || layers.isEmpty()) { + throw new InvalidArgumentException("At least one layer required"); + } + firstLayer = layers.get(0); + global = false; + hasLocalFile = layers.stream().anyMatch(GpxLayer::isLocalFile); + hasNonLocalFile = layers.stream().anyMatch(l -> !l.isLocalFile()); initComponents(); loadPreferences(); @@ -118,8 +160,137 @@ public GPXSettingsPanel() { super(new GridBagLayout()); + layers = null; + firstLayer = null; + global = hasLocalFile = hasNonLocalFile = true; initComponents(); - local = false; - nonlocal = false; loadPreferences(); // preferences -> controls + } + + /** + * Reads the preference for the given layer or the default preference if not available + * @param layer the GpxLayer. Can be null, default preference will be returned then + * @param key the drawing key to be read, without "draw.rawgps." + * @return the value + */ + public static String getLayerPref(GpxLayer layer, String key) { + Object d = DEFAULT_PREFS.get(key); + String ds; + if (d != null) { + ds = d.toString(); + } else { + Logging.warn("No default value found for layer preference \"" + key + "\"."); + ds = null; + } + return Optional.ofNullable(tryGetLayerPrefLocal(layer, key)).orElse(Config.getPref().get("draw.rawgps." + key, ds)); + } + + /** + * Reads the integer preference for the given layer or the default preference if not available + * @param layer the GpxLayer. Can be null, default preference will be returned then + * @param key the drawing key to be read, without "draw.rawgps." + * @return the integer value + */ + public static int getLayerPrefInt(GpxLayer layer, String key) { + String s = getLayerPref(layer, key); + if (s != null) { + try { + return Integer.parseInt(s); + } catch (NumberFormatException ex) { + Object d = DEFAULT_PREFS.get(key); + if (d instanceof Integer) { + return (int) d; + } else { + Logging.warn("No valid default value found for layer preference \"" + key + "\"."); + } + } + } + return 0; + } + + /** + * Try to read the preference for the given layer + * @param layer the GpxLayer + * @param key the drawing key to be read, without "draw.rawgps." + * @return the value or null if not found + */ + public static String tryGetLayerPrefLocal(GpxLayer layer, String key) { + return layer != null ? tryGetLayerPrefLocal(layer.data, key) : null; + } + + /** + * Try to read the preference for the given GpxData + * @param data the GpxData + * @param key the drawing key to be read, without "draw.rawgps." + * @return the value or null if not found + */ + public static String tryGetLayerPrefLocal(GpxData data, String key) { + return data != null ? data.getLayerPrefs().get(key) : null; + } + + /** + * Puts the preference for the given layers or the default preference if layers is null + * @param layers List of GpxLayer to put the drawingOptions + * @param key the drawing key to be written, without "draw.rawgps." + * @param value (can be null to remove option) + */ + public static void putLayerPref(List layers, String key, Object value) { + String v = value == null ? null : value.toString(); + if (layers != null) { + for (GpxLayer l : layers) { + putLayerPrefLocal(l.data, key, v); + } + } else { + Config.getPref().put("draw.rawgps." + key, v); + } + } + + /** + * Puts the preference for the given layer + * @param layer GpxLayer to put the drawingOptions + * @param key the drawing key to be written, without "draw.rawgps." + * @param value the value or null to remove key + */ + public static void putLayerPrefLocal(GpxLayer layer, String key, String value) { + if (layer == null) return; + putLayerPrefLocal(layer.data, key, value); + } + + /** + * Puts the preference for the given layer + * @param data GpxData to put the drawingOptions. Must not be null + * @param key the drawing key to be written, without "draw.rawgps." + * @param value the value or null to remove key + */ + public static void putLayerPrefLocal(GpxData data, String key, String value) { + if (value == null || value.trim().isEmpty() || (getLayerPref(null, key).equals(value) && DEFAULT_PREFS.get(key) != null && DEFAULT_PREFS.get(key).toString().equals(value))) { + data.getLayerPrefs().remove(key); + } else { + data.getLayerPrefs().put(key, value); + } + } + + private String pref(String key) { + return getLayerPref(firstLayer, key); + } + + private boolean prefBool(String key) { + return Boolean.parseBoolean(pref(key)); + } + + private int prefInt(String key) { + return getLayerPrefInt(firstLayer, key); + } + + private int prefIntLocal(String key) { + try { + return Integer.parseInt(tryGetLayerPrefLocal(firstLayer, key)); + } catch (NumberFormatException ex) { + return -1; + } + + } + + private void putPref(String key, Object value) { + putLayerPref(layers, key, value); } @@ -128,12 +299,14 @@ setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); - // makeAutoMarkers - makeAutoMarkers.setToolTipText(tr("Automatically make a marker layer from any waypoints when opening a GPX layer.")); - ExpertToggleAction.addVisibilitySwitcher(makeAutoMarkers); - add(makeAutoMarkers, GBC.eol().insets(20, 0, 0, 5)); + if (global) { + // makeAutoMarkers + makeAutoMarkers.setToolTipText(tr("Automatically make a marker layer from any waypoints when opening a GPX layer.")); + ExpertToggleAction.addVisibilitySwitcher(makeAutoMarkers); + add(makeAutoMarkers, GBC.eol().insets(20, 0, 0, 5)); + } // drawRawGpsLines ButtonGroup gpsLinesGroup = new ButtonGroup(); - if (layerName != null) { + if (!global) { gpsLinesGroup.add(drawRawGpsLinesGlobal); } @@ -146,12 +319,12 @@ JLabel label = new JLabel(tr("Draw lines between raw GPS points")); add(label, GBC.eol().insets(20, 0, 0, 0)); - if (layerName != null) { + if (!global) { add(drawRawGpsLinesGlobal, GBC.eol().insets(40, 0, 0, 0)); } add(drawRawGpsLinesNone, GBC.eol().insets(40, 0, 0, 0)); - if (layerName == null || local) { + if (hasLocalFile) { add(drawRawGpsLinesLocal, GBC.eol().insets(40, 0, 0, 0)); } - if (layerName == null || nonlocal) { + if (hasNonLocalFile) { add(drawRawGpsLinesAll, GBC.eol().insets(40, 0, 0, 0)); } @@ -243,5 +416,5 @@ // colorTracks ButtonGroup colorGroup = new ButtonGroup(); - if (layerName != null) { + if (!global) { colorGroup.add(colorTypeGlobal); } @@ -254,5 +427,5 @@ colorGroup.add(colorTypeHeatMap); - colorTypeNone.setToolTipText(tr("All points and track segments will have the same color. Can be customized in Layer Manager.")); + colorTypeNone.setToolTipText(tr("All points and track segments will have their own color. Can be customized in Layer Manager.")); colorTypeVelocity.setToolTipText(tr("Colors points and track segments by velocity.")); colorTypeDirection.setToolTipText(tr("Colors points and track segments by direction.")); @@ -273,5 +446,5 @@ add(new JLabel(tr("Track and Point Coloring")), GBC.eol().insets(20, 0, 0, 0)); - if (layerName != null) { + if (!global) { add(colorTypeGlobal, GBC.eol().insets(40, 0, 0, 0)); } @@ -332,13 +505,8 @@ // get image size of environment final int iconSize = (int) dim.getHeight(); - final Color color; - // ask the GPX draw for the correct color of that layer ( if there is one ) - if (null != layerName) { - color = GpxDrawHelper.DEFAULT_COLOR.getChildColor( - NamedColorProperty.COLOR_CATEGORY_LAYER, layerName, GpxDrawHelper.DEFAULT_COLOR.getName()).get(); - } else { - color = GpxDrawHelper.DEFAULT_COLOR.getDefaultValue(); - } - colorTypeHeatIconLabel.setIcon(GpxDrawHelper.getColorMapImageIcon(color, colorTypeHeatMapTune.getSelectedIndex(), iconSize)); + colorTypeHeatIconLabel.setIcon(GpxDrawHelper.getColorMapImageIcon( + GpxDrawHelper.DEFAULT_COLOR_PROPERTY.get(), + colorTypeHeatMapTune.getSelectedIndex(), + iconSize)); } }); @@ -354,5 +522,5 @@ ExpertToggleAction.addVisibilitySwitcher(colorDynamic); - if (layerName == null) { + if (global) { // Setting waypoints for gpx layer doesn't make sense - waypoints are shown in marker layer that has different name - so show // this only for global config @@ -364,5 +532,4 @@ add(waypointLabel, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5)); waypointLabel.addActionListener(e -> updateWaypointPattern(waypointLabel, waypointLabelPattern)); - updateWaypointLabelCombobox(waypointLabel, waypointLabelPattern, TemplateEntryProperty.forMarker(layerName)); add(waypointLabelPattern, GBC.eol().fill(GBC.HORIZONTAL).insets(20, 0, 0, 5)); ExpertToggleAction.addVisibilitySwitcher(label); @@ -380,5 +547,4 @@ add(audioWaypointLabel, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5)); audioWaypointLabel.addActionListener(e -> updateWaypointPattern(audioWaypointLabel, audioWaypointLabelPattern)); - updateWaypointLabelCombobox(audioWaypointLabel, audioWaypointLabelPattern, TemplateEntryProperty.forAudioMarker(layerName)); add(audioWaypointLabelPattern, GBC.eol().fill(GBC.HORIZONTAL).insets(20, 0, 0, 5)); ExpertToggleAction.addVisibilitySwitcher(label); @@ -396,44 +562,30 @@ public final void loadPreferences() { makeAutoMarkers.setSelected(Config.getPref().getBoolean("marker.makeautomarkers", true)); - if (layerName != null && Config.getPref().get("draw.rawgps.lines."+layerName).isEmpty() - && Config.getPref().get("draw.rawgps.lines.local."+layerName).isEmpty()) { - // no line preferences for layer is found + int lines = global ? prefInt("lines") : prefIntLocal("lines"); + if (lines == 2 && hasNonLocalFile) { + drawRawGpsLinesAll.setSelected(true); + } else if ((lines == 1 && hasLocalFile) || (lines == -1 && global)) { + drawRawGpsLinesLocal.setSelected(true); + } else if (lines == 0) { + drawRawGpsLinesNone.setSelected(true); + } else if (lines == -1) { drawRawGpsLinesGlobal.setSelected(true); } else { - Boolean lf = PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines.local", layerName, true); - if (PreferencesUtils.getBoolean(Config.getPref(), "draw.rawgps.lines", layerName, true)) { - drawRawGpsLinesAll.setSelected(true); - } else if (lf) { - drawRawGpsLinesLocal.setSelected(true); - } else { - drawRawGpsLinesNone.setSelected(true); - } - } - - drawRawGpsMaxLineLengthLocal.setText(Integer.toString(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.max-line-length.local", layerName, -1))); - drawRawGpsMaxLineLength.setText(Integer.toString(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.max-line-length", layerName, 200))); - drawLineWidth.setText(Integer.toString(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.linewidth", layerName, 0))); - drawLineWithAlpha.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.lines.alpha-blend", layerName, false)); - forceRawGpsLines.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.lines.force", layerName, false)); - drawGpsArrows.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.direction", layerName, false)); - drawGpsArrowsFast.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.alternatedirection", layerName, false)); - drawGpsArrowsMinDist.setText(Integer.toString(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.min-arrow-distance", layerName, 40))); - hdopCircleGpsPoints.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.hdopcircle", layerName, false)); - largeGpsPoints.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.large", layerName, false)); + Logging.warn("Unknown line type: " + lines); + } + drawRawGpsMaxLineLengthLocal.setText(pref("lines.max-length.local")); + drawRawGpsMaxLineLength.setText(pref("lines.max-length")); + drawLineWidth.setText(pref("lines.width")); + drawLineWithAlpha.setSelected(prefBool("lines.alpha-blend")); + forceRawGpsLines.setSelected(prefBool("lines.force")); + drawGpsArrows.setSelected(prefBool("lines.arrows")); + drawGpsArrowsFast.setSelected(prefBool("lines.arrows.fast")); + drawGpsArrowsMinDist.setText(pref("lines.arrows.min-distance")); + hdopCircleGpsPoints.setSelected(prefBool("points.hdopcircle")); + largeGpsPoints.setSelected(prefBool("points.large")); useGpsAntialiasing.setSelected(Config.getPref().getBoolean("mappaint.gpx.use-antialiasing", false)); drawRawGpsLinesActionListener.actionPerformed(null); - - if (layerName != null && Config.getPref().get("draw.rawgps.colors."+layerName).isEmpty()) { + if (!global && prefIntLocal("colormode") == -1) { colorTypeGlobal.setSelected(true); colorDynamic.setSelected(false); @@ -443,7 +595,7 @@ colorTypeHeatMapLowerLimit.setValue(0); } else { - int colorType = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.colors", layerName, 0); + int colorType = prefInt("colormode"); switch (colorType) { - case 0: colorTypeNone.setSelected(true); break; + case -1: case 0: colorTypeNone.setSelected(true); break; case 1: colorTypeVelocity.setSelected(true); break; case 2: colorTypeDilution.setSelected(true); break; @@ -454,108 +606,97 @@ default: Logging.warn("Unknown color type: " + colorType); } - int ccts = PreferencesUtils.getInteger(Config.getPref(), "draw.rawgps.colorTracksTune", layerName, 45); + int ccts = prefInt("colormode.velocity.tune"); colorTypeVelocityTune.setSelectedIndex(ccts == 10 ? 2 : (ccts == 20 ? 1 : 0)); - colorTypeHeatMapTune.setSelectedIndex(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.heatmap.colormap", layerName, 0)); - colorDynamic.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.colors.dynamic", layerName, false)); - colorTypeHeatMapPoints.setSelected(PreferencesUtils.getBoolean(Config.getPref(), - "draw.rawgps.heatmap.use-points", layerName, false)); - colorTypeHeatMapGain.setValue(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.heatmap.gain", layerName, 0)); - colorTypeHeatMapLowerLimit.setValue(PreferencesUtils.getInteger(Config.getPref(), - "draw.rawgps.heatmap.lower-limit", layerName, 0)); - } - } - - /** - * Save preferences from UI controls, globally or for a specified layer. - * @param layerName The GPX layer name. Can be {@code null}, in that case, global preferences are written - * @param locLayer {@code true} if the GPX layer is a local one. Ignored if {@code layerName} is null + colorTypeHeatMapTune.setSelectedIndex(prefInt("colormode.heatmap.colormap")); + colorDynamic.setSelected(prefBool("colormode.dynamic-range")); + colorTypeHeatMapPoints.setSelected(prefBool("colormode.heatmap.use-points")); + colorTypeHeatMapGain.setValue(prefInt("colormode.heatmap.gain")); + colorTypeHeatMapLowerLimit.setValue(prefInt("colormode.heatmap.lower-limit")); + } + updateWaypointLabelCombobox(waypointLabel, waypointLabelPattern, pref("markers.pattern")); + updateWaypointLabelCombobox(audioWaypointLabel, audioWaypointLabelPattern, pref("markers.audio.pattern")); + + } + + /** + * Save preferences from UI controls, globally or for the specified layers. * @return {@code true} when restart is required, {@code false} otherwise */ - public boolean savePreferences(String layerName, boolean locLayer) { - String layerNameDot = ".layer "+layerName; - if (layerName == null) { - layerNameDot = ""; - } - Config.getPref().putBoolean("marker.makeautomarkers"+layerNameDot, makeAutoMarkers.isSelected()); - if (drawRawGpsLinesGlobal.isSelected()) { - Config.getPref().put("draw.rawgps.lines" + layerNameDot, null); - Config.getPref().put("draw.rawgps.max-line-length" + layerNameDot, null); - Config.getPref().put("draw.rawgps.lines.local" + layerNameDot, null); - Config.getPref().put("draw.rawgps.max-line-length.local" + layerNameDot, null); - Config.getPref().put("draw.rawgps.lines.force"+layerNameDot, null); - Config.getPref().put("draw.rawgps.direction"+layerNameDot, null); - Config.getPref().put("draw.rawgps.alternatedirection"+layerNameDot, null); - Config.getPref().put("draw.rawgps.min-arrow-distance"+layerNameDot, null); + public boolean savePreferences() { + if (global) { + Config.getPref().putBoolean("marker.makeautomarkers", makeAutoMarkers.isSelected()); + putPref("markers.pattern", waypointLabelPattern.getText()); + putPref("markers.audio.pattern", audioWaypointLabelPattern.getText()); + } + boolean g; + if (!global && ((g = drawRawGpsLinesGlobal.isSelected()) || drawRawGpsLinesNone.isSelected())) { + if (g) { + putPref("lines", null); + } else { + putPref("lines", 0); + } + putPref("lines.max-length", null); + putPref("lines.max-length.local", null); + putPref("lines.force", null); + putPref("lines.arrows", null); + putPref("lines.arrows.fast", null); + putPref("lines.arrows.min-distance", null); } else { - if (layerName == null || !locLayer) { - Config.getPref().putBoolean("draw.rawgps.lines" + layerNameDot, drawRawGpsLinesAll.isSelected()); - Config.getPref().put("draw.rawgps.max-line-length" + layerNameDot, drawRawGpsMaxLineLength.getText()); + if (drawRawGpsLinesLocal.isSelected()) { + putPref("lines", 1); + } else if (drawRawGpsLinesAll.isSelected()) { + putPref("lines", 2); } - if (layerName == null || locLayer) { - Config.getPref().putBoolean("draw.rawgps.lines.local" + layerNameDot, - drawRawGpsLinesAll.isSelected() || drawRawGpsLinesLocal.isSelected()); - Config.getPref().put("draw.rawgps.max-line-length.local" + layerNameDot, - drawRawGpsMaxLineLengthLocal.getText()); - } - Config.getPref().putBoolean("draw.rawgps.lines.force"+layerNameDot, forceRawGpsLines.isSelected()); - Config.getPref().putBoolean("draw.rawgps.direction"+layerNameDot, drawGpsArrows.isSelected()); - Config.getPref().putBoolean("draw.rawgps.alternatedirection"+layerNameDot, drawGpsArrowsFast.isSelected()); - Config.getPref().put("draw.rawgps.min-arrow-distance"+layerNameDot, drawGpsArrowsMinDist.getText()); - } - - Config.getPref().putBoolean("draw.rawgps.hdopcircle"+layerNameDot, hdopCircleGpsPoints.isSelected()); - Config.getPref().putBoolean("draw.rawgps.large"+layerNameDot, largeGpsPoints.isSelected()); - Config.getPref().put("draw.rawgps.linewidth"+layerNameDot, drawLineWidth.getText()); - Config.getPref().putBoolean("draw.rawgps.lines.alpha-blend"+layerNameDot, drawLineWithAlpha.isSelected()); + putPref("lines.max-length", drawRawGpsMaxLineLength.getText()); + putPref("lines.max-length.local", drawRawGpsMaxLineLengthLocal.getText()); + putPref("lines.force", forceRawGpsLines.isSelected()); + putPref("lines.arrows", drawGpsArrows.isSelected()); + putPref("lines.arrows.fast", drawGpsArrowsFast.isSelected()); + putPref("lines.arrows.min-distance", drawGpsArrowsMinDist.getText()); + } + + putPref("points.hdopcircle", hdopCircleGpsPoints.isSelected()); + putPref("points.large", largeGpsPoints.isSelected()); + putPref("lines.width", drawLineWidth.getText()); + putPref("lines.alpha-blend", drawLineWithAlpha.isSelected()); Config.getPref().putBoolean("mappaint.gpx.use-antialiasing", useGpsAntialiasing.isSelected()); - TemplateEntryProperty.forMarker(layerName).put(waypointLabelPattern.getText()); - TemplateEntryProperty.forAudioMarker(layerName).put(audioWaypointLabelPattern.getText()); - if (colorTypeGlobal.isSelected()) { - Config.getPref().put("draw.rawgps.colors"+layerNameDot, null); - Config.getPref().put("draw.rawgps.colors.dynamic"+layerNameDot, null); - Config.getPref().put("draw.rawgps.colorTracksTunec"+layerNameDot, null); + putPref("colormode", null); + putPref("colormode.dynamic-range", null); + putPref("colormode.velocity.tune", null); return false; } else if (colorTypeVelocity.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 1); + putPref("colormode", 1); } else if (colorTypeDilution.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 2); + putPref("colormode", 2); } else if (colorTypeDirection.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 3); + putPref("colormode", 3); } else if (colorTypeTime.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 4); + putPref("colormode", 4); } else if (colorTypeHeatMap.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 5); + putPref("colormode", 5); } else if (colorTypeQuality.isSelected()) { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 6); + putPref("colormode", 6); } else { - Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 0); - } - Config.getPref().putBoolean("draw.rawgps.colors.dynamic"+layerNameDot, colorDynamic.isSelected()); + putPref("colormode", 0); + } + putPref("colormode.dynamic-range", colorDynamic.isSelected()); int ccti = colorTypeVelocityTune.getSelectedIndex(); - Config.getPref().putInt("draw.rawgps.colorTracksTune"+layerNameDot, ccti == 2 ? 10 : (ccti == 1 ? 20 : 45)); - Config.getPref().putInt("draw.rawgps.heatmap.colormap"+layerNameDot, colorTypeHeatMapTune.getSelectedIndex()); - Config.getPref().putBoolean("draw.rawgps.heatmap.use-points"+layerNameDot, colorTypeHeatMapPoints.isSelected()); - Config.getPref().putInt("draw.rawgps.heatmap.gain"+layerNameDot, colorTypeHeatMapGain.getValue()); - Config.getPref().putInt("draw.rawgps.heatmap.lower-limit"+layerNameDot, colorTypeHeatMapLowerLimit.getValue()); + putPref("colormode.velocity.tune", ccti == 2 ? 10 : (ccti == 1 ? 20 : 45)); + putPref("colormode.heatmap.colormap", colorTypeHeatMapTune.getSelectedIndex()); + putPref("colormode.heatmap.use-points", colorTypeHeatMapPoints.isSelected()); + putPref("colormode.heatmap.gain", colorTypeHeatMapGain.getValue()); + putPref("colormode.heatmap.lower-limit", colorTypeHeatMapLowerLimit.getValue()); + + if (!global && layers != null && !layers.isEmpty()) { + layers.forEach(l -> l.data.invalidate()); + } return false; } - /** - * Save preferences from UI controls for initial layer or globally - * @return {@code true} when restart is required, {@code false} otherwise - */ - public boolean savePreferences() { - return savePreferences(null, false); - } - - private static void updateWaypointLabelCombobox(JosmComboBox cb, JosmTextField tf, TemplateEntryProperty property) { - String labelPattern = property.getAsString(); + private static void updateWaypointLabelCombobox(JosmComboBox cb, JosmTextField tf, String labelPattern) { boolean found = false; for (int i = 0; i < LABEL_PATTERN_TEMPLATE.length; i++) { Index: /trunk/src/org/openstreetmap/josm/io/GpxReader.java =================================================================== --- /trunk/src/org/openstreetmap/josm/io/GpxReader.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/io/GpxReader.java (revision 15496) @@ -19,10 +19,13 @@ import org.openstreetmap.josm.data.Bounds; import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.data.gpx.Extensions; import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxData.XMLNamespace; +import org.openstreetmap.josm.data.gpx.GpxExtensionCollection; import org.openstreetmap.josm.data.gpx.GpxLink; import org.openstreetmap.josm.data.gpx.GpxRoute; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.tools.Logging; @@ -68,5 +71,5 @@ private GpxData data; - private Collection> currentTrack; + private Collection currentTrack; private Map currentTrackAttr; private Collection currentTrackSeg; @@ -77,5 +80,6 @@ private GpxLink currentLink; - private Extensions currentExtensions; + private GpxExtensionCollection currentExtensionCollection; + private GpxExtensionCollection currentTrackExtensionCollection; private Stack states; private final Stack elements = new Stack<>(); @@ -89,5 +93,12 @@ accumulator = new StringBuilder(); states = new Stack<>(); - data = new GpxData(); + data = new GpxData(true); + currentExtensionCollection = new GpxExtensionCollection(); + currentTrackExtensionCollection = new GpxExtensionCollection(); + } + + @Override + public void startPrefixMapping(String prefix, String uri) throws SAXException { + data.getNamespaces().add(new XMLNamespace(prefix, uri)); } @@ -134,4 +145,15 @@ version = "1.1"; } + String schemaLocation = atts.getValue(GpxConstants.XML_URI_XSD, "schemaLocation"); + if (schemaLocation != null) { + String[] schemaLocations = schemaLocation.split(" "); + for (int i = 0; i < schemaLocations.length - 1; i += 2) { + final String schemaURI = schemaLocations[i]; + final String schemaXSD = schemaLocations[i + 1]; + data.getNamespaces().stream().filter(xml -> xml.getURI().equals(schemaURI)).forEach(xml -> { + xml.setLocation(schemaXSD); + }); + } + } break; case GPX: @@ -160,5 +182,4 @@ states.push(currentState); currentState = State.EXT; - currentExtensions = new Extensions(); break; case "gpx": @@ -179,5 +200,4 @@ states.push(currentState); currentState = State.EXT; - currentExtensions = new Extensions(); break; case "copyright": @@ -229,5 +249,4 @@ states.push(currentState); currentState = State.EXT; - currentExtensions = new Extensions(); break; default: // Do nothing @@ -235,8 +254,14 @@ break; case TRKSEG: - if ("trkpt".equals(localName)) { + switch (localName) { + case "trkpt": states.push(currentState); currentState = State.WPT; currentWayPoint = new WayPoint(parseLatLon(atts)); + break; + case "extensions": + states.push(currentState); + currentState = State.EXT; + break; } break; @@ -251,5 +276,4 @@ states.push(currentState); currentState = State.EXT; - currentExtensions = new Extensions(); break; default: // Do nothing @@ -271,7 +295,13 @@ states.push(currentState); currentState = State.EXT; - currentExtensions = new Extensions(); - break; - default: // Do nothing + break; + default: // Do nothing + } + break; + case EXT: + if (states.lastElement() == State.TRK) { + currentTrackExtensionCollection.openChild(namespaceURI, qName, atts); + } else { + currentExtensionCollection.openChild(namespaceURI, qName, atts); } break; @@ -350,7 +380,6 @@ (currentState == State.GPX && "gpx".equals(localName))) { convertUrlToLink(data.attr); - if (currentExtensions != null && !currentExtensions.isEmpty()) { - data.put(META_EXTENSIONS, currentExtensions); - } + data.getExtensions().addAll(currentExtensionCollection); + currentExtensionCollection.clear(); currentState = states.pop(); } @@ -360,5 +389,4 @@ break; default: - //TODO: parse extensions } break; @@ -465,8 +493,7 @@ currentState = states.pop(); convertUrlToLink(currentWayPoint.attr); - if (currentExtensions != null && !currentExtensions.isEmpty()) { - currentWayPoint.put(META_EXTENSIONS, currentExtensions); - } + currentWayPoint.getExtensions().addAll(currentExtensionCollection); data.waypoints.add(currentWayPoint); + currentExtensionCollection.clear(); break; default: // Do nothing @@ -476,5 +503,10 @@ if ("trkseg".equals(localName)) { currentState = states.pop(); - currentTrack.add(currentTrackSeg); + if (!currentTrackSeg.isEmpty()) { + GpxTrackSegment seg = new GpxTrackSegment(currentTrackSeg); + seg.getExtensions().addAll(currentExtensionCollection); + currentTrack.add(seg); + } + currentExtensionCollection.clear(); } break; @@ -484,5 +516,8 @@ currentState = states.pop(); convertUrlToLink(currentTrackAttr); - data.addTrack(new ImmutableGpxTrack(currentTrack, currentTrackAttr)); + GpxTrack trk = new GpxTrack(new ArrayList<>(currentTrack), currentTrackAttr); + trk.getExtensions().addAll(currentTrackExtensionCollection); + data.addTrack(trk); + currentTrackExtensionCollection.clear(); break; case "name": @@ -502,7 +537,11 @@ if ("extensions".equals(localName)) { currentState = states.pop(); - } else if (JOSM_EXTENSIONS_NAMESPACE_URI.equals(namespaceURI)) { - // only interested in extensions written by JOSM - currentExtensions.put(localName, accumulator.toString()); + } else if (currentExtensionCollection != null) { + String acc = accumulator.toString().trim(); + if (states.lastElement() == State.TRK) { + currentTrackExtensionCollection.closeChild(qName, acc); //a segment inside the track can have an extension too + } else { + currentExtensionCollection.closeChild(qName, acc); + } } break; @@ -520,4 +559,5 @@ } } + accumulator.setLength(0); } @@ -526,8 +566,19 @@ if (!states.empty()) throw new SAXException(tr("Parse error: invalid document structure for GPX document.")); - Extensions metaExt = (Extensions) data.get(META_EXTENSIONS); - if (metaExt != null && "true".equals(metaExt.get("from-server"))) { - data.fromServer = true; - } + + data.getExtensions().stream("josm", "from-server").findAny().ifPresent(ext -> { + data.fromServer = "true".equals(ext.getValue()); + }); + + data.getExtensions().stream("josm", "layerPreferences").forEach(prefs -> { + prefs.getExtensions().stream("josm", "entry").forEach(prefEntry -> { + Object key = prefEntry.get("key"); + Object val = prefEntry.get("value"); + if (key != null && val != null) { + data.getLayerPrefs().put(key.toString(), val.toString()); + } + }); + }); + data.endUpdate(); gpxData = data; } Index: /trunk/src/org/openstreetmap/josm/io/GpxWriter.java =================================================================== --- /trunk/src/org/openstreetmap/josm/io/GpxWriter.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/io/GpxWriter.java (revision 15496) @@ -9,9 +9,11 @@ import java.io.PrintWriter; import java.nio.charset.StandardCharsets; +import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.List; import java.util.Map; -import java.util.Map.Entry; +import java.util.Objects; +import java.util.stream.Collectors; import javax.xml.XMLConstants; @@ -19,11 +21,13 @@ import org.openstreetmap.josm.data.Bounds; import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.data.gpx.Extensions; import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxData.XMLNamespace; +import org.openstreetmap.josm.data.gpx.GpxExtension; +import org.openstreetmap.josm.data.gpx.GpxExtensionCollection; import org.openstreetmap.josm.data.gpx.GpxLink; import org.openstreetmap.josm.data.gpx.GpxRoute; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.IWithAttributes; import org.openstreetmap.josm.data.gpx.WayPoint; @@ -55,4 +59,5 @@ private GpxData data; private String indent = ""; + private List validprefixes; private static final int WAY_POINT = 0; @@ -65,27 +70,75 @@ */ public void write(GpxData data) { + write(data, ColorFormat.GPXD, true); + } + + /** + * Writes the given GPX data. + * + * @param data The data to write + * @param colorFormat determines if colors are saved and which extension is to be used + * @param savePrefs whether layer specific preferences are saved + */ + public void write(GpxData data, ColorFormat colorFormat, boolean savePrefs) { this.data = data; - // We write JOSM specific meta information into gpx 'extensions' elements. - // In particular it is noted whether the gpx data is from the OSM server - // (so the rendering of clouds of anonymous TrackPoints can be improved) - // and some extra synchronization info for export of AudioMarkers. - // It is checked in advance, if any extensions are used, so we know whether - // a namespace declaration is necessary. - boolean hasExtensions = data.fromServer; - if (!hasExtensions) { - for (WayPoint wpt : data.waypoints) { - Extensions extensions = (Extensions) wpt.get(META_EXTENSIONS); - if (extensions != null && !extensions.isEmpty()) { - hasExtensions = true; - break; - } - } - } + + //Prepare extensions for writing + data.beginUpdate(); + data.getTracks().forEach(trk -> trk.convertColor(colorFormat)); + data.getExtensions().removeAllWithPrefix("josm"); + if (data.fromServer) { + data.getExtensions().add("josm", "from-server", "true"); + } + if (savePrefs && !data.getLayerPrefs().isEmpty()) { + GpxExtensionCollection layerExts = data.getExtensions().add("josm", "layerPreferences").getExtensions(); + data.getLayerPrefs().entrySet() + .stream() + .sorted((e1, e2) -> e1.getKey().compareTo(e2.getKey())) + .forEach(entry -> { + GpxExtension e = layerExts.add("josm", "entry"); + e.put("key", entry.getKey()); + e.put("value", entry.getValue()); + }); + } + data.endUpdate(); + + Collection all = new ArrayList<>(); + + all.add(data); + all.addAll(data.getWaypoints()); + all.addAll(data.getRoutes()); + all.addAll(data.getTracks()); + all.addAll(data.getTrackSegmentsStream().collect(Collectors.toList())); + + List namespaces = all + .stream() + .flatMap(w -> w.getExtensions().getPrefixesStream()) + .distinct() + .map(p -> data.getNamespaces() + .stream() + .filter(s -> s.getPrefix().equals(p)) + .findAny() + .orElse(GpxExtension.findNamespace(p))) + .filter(Objects::nonNull) + .collect(Collectors.toList()); + + validprefixes = namespaces.stream().map(n -> n.getPrefix()).collect(Collectors.toList()); out.println(""); out.println(""); + + String schemaLocations = "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd"; + + for (XMLNamespace n : namespaces) { + if (n.getURI() != null && n.getPrefix() != null && !n.getPrefix().isEmpty()) { + out.println(String.format(" xmlns:%s=\"%s\"", n.getPrefix(), n.getURI())); + if (n.getLocation() != null) { + schemaLocations += " " + n.getURI() + " " + n.getLocation(); + } + } + } + + out.println(" xmlns:xsi=\""+XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI+"\""); + out.println(String.format(" xsi:schemaLocation=\"%s\">", schemaLocations)); indent = " "; writeMetaData(); @@ -105,9 +158,4 @@ gpxLink(link); } - } - } else if (META_EXTENSIONS.equals(key)) { - Extensions extensions = (Extensions) obj.get(key); - if (extensions != null) { - gpxExtensions(extensions); } } else { @@ -148,5 +196,5 @@ String[] tmp = data.getString(META_AUTHOR_EMAIL).split("@"); if (tmp.length == 2) { - inline("email", "id=\"" + tmp[0] + "\" domain=\""+tmp[1]+'\"'); + inline("email", "id=\"" + encode(tmp[0]) + "\" domain=\"" + encode(tmp[1]) +'\"'); } } @@ -159,5 +207,5 @@ if (attr.containsKey(META_COPYRIGHT_LICENSE) || attr.containsKey(META_COPYRIGHT_YEAR)) { - openAtt("copyright", "author=\""+ data.get(META_COPYRIGHT_AUTHOR) +'\"'); + openln("copyright", "author=\""+ encode(data.get(META_COPYRIGHT_AUTHOR).toString()) +'\"'); if (attr.containsKey(META_COPYRIGHT_YEAR)) { simpleTag("year", (String) data.get(META_COPYRIGHT_YEAR)); @@ -188,10 +236,5 @@ } - if (data.fromServer) { - openln("extensions"); - simpleTag("josm:from-server", "true"); - closeln("extensions"); - } - + gpxExtensions(data.getExtensions()); closeln("metadata"); } @@ -207,4 +250,5 @@ openln("rte"); writeAttr(rte, RTE_TRK_KEYS); + gpxExtensions(rte.getExtensions()); for (WayPoint pnt : rte.routePoints) { wayPoint(pnt, ROUTE_POINT); @@ -218,6 +262,8 @@ openln("trk"); writeAttr(trk, RTE_TRK_KEYS); - for (GpxTrackSegment seg : trk.getSegments()) { + gpxExtensions(trk.getExtensions()); + for (IGpxTrackSegment seg : trk.getSegments()) { openln("trkseg"); + gpxExtensions(seg.getExtensions()); for (WayPoint pnt : seg.getWayPoints()) { wayPoint(pnt, TRACK_POINT); @@ -234,4 +280,9 @@ } + private void openln(String tag, String attributes) { + open(tag, attributes); + out.println(); + } + private void open(String tag) { out.print(indent + '<' + tag + '>'); @@ -239,11 +290,11 @@ } - private void openAtt(String tag, String attributes) { - out.println(indent + '<' + tag + ' ' + attributes + '>'); + private void open(String tag, String attributes) { + out.print(indent + '<' + tag + (attributes.isEmpty() ? "" : ' ') + attributes + '>'); indent += " "; } private void inline(String tag, String attributes) { - out.println(indent + '<' + tag + ' ' + attributes + "/>"); + out.println(indent + '<' + tag + (attributes.isEmpty() ? "" : ' ') + attributes + "/>"); } @@ -273,4 +324,13 @@ } + private void simpleTag(String tag, String content, String attributes) { + if (content != null && !content.isEmpty()) { + open(tag, attributes); + out.print(encode(content)); + out.println("'); + indent = indent.substring(2); + } + } + /** * output link @@ -279,5 +339,5 @@ private void gpxLink(GpxLink link) { if (link != null) { - openAtt("link", "href=\"" + link.uri + '\"'); + openln("link", "href=\"" + encode(link.uri) + '\"'); simpleTag("text", link.text); simpleTag("type", link.type); @@ -309,9 +369,10 @@ LatLon c = pnt.getCoor(); String coordAttr = "lat=\"" + c.lat() + "\" lon=\"" + c.lon() + '\"'; - if (pnt.attr.isEmpty()) { + if (pnt.attr.isEmpty() && pnt.getExtensions().isEmpty()) { inline(type, coordAttr); } else { - openAtt(type, coordAttr); + openln(type, coordAttr); writeAttr(pnt, WPT_KEYS); + gpxExtensions(pnt.getExtensions()); closeln(type); } @@ -319,12 +380,33 @@ } - private void gpxExtensions(Extensions extensions) { - if (extensions != null && !extensions.isEmpty()) { + private void gpxExtensions(GpxExtensionCollection allExtensions) { + if (allExtensions.isVisible()) { openln("extensions"); - for (Entry e : extensions.entrySet()) { - simpleTag("josm:" + e.getKey(), e.getValue()); - } + writeExtension(allExtensions); closeln("extensions"); } } + + private void writeExtension(List extensions) { + for (GpxExtension e : extensions) { + if (validprefixes.contains(e.getPrefix()) && e.isVisible()) { + // this might lead to loss of an unknown extension *after* the file was saved as .osm, + // but otherwise the file is invalid and can't even be parsed by SAX anymore + String k = (e.getPrefix().isEmpty() ? "" : e.getPrefix() + ":") + e.getKey(); + String attr = String.join(" ", e.getAttributes().entrySet().stream().map(a -> encode(a.getKey()) + "=\"" + encode(a.getValue().toString()) + "\"").sorted().collect(Collectors.toList())); + if (e.getValue() == null && e.getExtensions().isEmpty()) { + inline(k, attr); + } else if (e.getExtensions().isEmpty()) { + simpleTag(k, e.getValue(), attr); + } else { + openln(k, attr); + if (e.getValue() != null) { + out.print(encode(e.getValue())); + } + writeExtension(e.getExtensions()); + closeln(k); + } + } + } + } } Index: /trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java =================================================================== --- /trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java (revision 15496) @@ -21,5 +21,5 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.io.IGpxReader; @@ -265,5 +265,5 @@ } currentTrack.add(ps.waypoints); - data.tracks.add(new ImmutableGpxTrack(currentTrack, Collections.emptyMap())); + data.tracks.add(new GpxTrack(currentTrack, Collections.emptyMap())); } catch (IllegalDataException e) { Index: /trunk/src/org/openstreetmap/josm/io/rtklib/RtkLibPosReader.java =================================================================== --- /trunk/src/org/openstreetmap/josm/io/rtklib/RtkLibPosReader.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/io/rtklib/RtkLibPosReader.java (revision 15496) @@ -19,5 +19,5 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.io.IGpxReader; @@ -115,5 +115,5 @@ } currentTrack.add(waypoints); - data.tracks.add(new ImmutableGpxTrack(currentTrack, Collections.emptyMap())); + data.tracks.add(new GpxTrack(currentTrack, Collections.emptyMap())); return true; } Index: /trunk/src/org/openstreetmap/josm/io/session/GenericSessionExporter.java =================================================================== --- /trunk/src/org/openstreetmap/josm/io/session/GenericSessionExporter.java (revision 15495) +++ /trunk/src/org/openstreetmap/josm/io/session/GenericSessionExporter.java (revision 15496) @@ -82,5 +82,5 @@ @Override public void actionPerformed(ActionEvent e) { - SaveAction.getInstance().doSave(layer); + SaveAction.getInstance().doSave(layer, true); updateEnabledState(); } Index: /trunk/test/data/tracks/tracks-extensions.gpx =================================================================== --- /trunk/test/data/tracks/tracks-extensions.gpx (revision 15496) +++ /trunk/test/data/tracks/tracks-extensions.gpx (revision 15496) @@ -0,0 +1,1378 @@ + + + + + + + + + + + + + Track extension + + Red + + + + + Segment extension + + + 471.86000000000001 + + + + 471.43000000000001 + + + + 470.69 + + + + 470.94 + + + + 471.5 + + + + 471.67000000000002 + + + + 471.58999999999997 + + + + 472.44999999999999 + + + + 472.54000000000002 + + + + 472.45999999999998 + + + + 471.38 + + + + 471.26999999999998 + + + + 471.36000000000001 + + + + 473.19999999999999 + + + + 475.06 + + + + 474.75 + + + + 474.62 + + + + 474.74000000000001 + + + + 474.06 + + + + 474 + + + + 474.58999999999997 + + + + 474.81999999999999 + + + + 476.29000000000002 + + + + 478.48000000000002 + + + + 481.02999999999997 + + + + 480 + + + + 479.58999999999997 + + + + 478.99000000000001 + + + + 479.58999999999997 + + + + 481.18000000000001 + + + + 481.88 + + + + 483.11000000000001 + + + + 484.49000000000001 + + + + 486.88 + + + + 488.05000000000001 + + + + 487.76999999999998 + + + + 488.95999999999998 + + + + 488.36000000000001 + + + + 488.35000000000002 + + + + 487.19 + + + + 487.63999999999999 + + + + 487.55000000000001 + + + + 488.39999999999998 + + + + 489.18000000000001 + + + + 490.73000000000002 + + + + 491.24000000000001 + + + + 490.25 + + + + 490.00999999999999 + + + + 489.54000000000002 + + + + 489.66000000000003 + + + + 489.06 + + + + 490.08999999999997 + + + + 489.41000000000003 + + + + 489.17000000000002 + + + + 488.87 + + + + 489.37 + + + + 488.94999999999999 + + + + 488.93000000000001 + + + + 488.88999999999999 + + + + 488.86000000000001 + + + + 489.19999999999999 + + + + 489.29000000000002 + + + + 488.95999999999998 + + + + 489.10000000000002 + + + + 492.19 + + + + 492.12 + + + + 493.06999999999999 + + + + 492.58999999999997 + + + + 492.38999999999999 + + + + 492.94 + + + + 492.47000000000003 + + + + 492.50999999999999 + + + + 492.73000000000002 + + + + 492.63 + + + + 493 + + + + 493.00999999999999 + + + + 493.19999999999999 + + + + 493.18000000000001 + + + + 493 + + + + 493.20999999999998 + + + + 493.11000000000001 + + + + 493.30000000000001 + + + + 493.50999999999999 + + + + 493 + + + + 492.37 + + + + 492.30000000000001 + + + + 492.04000000000002 + + + + 491.37 + + + + 491.06999999999999 + + + + 490.39999999999998 + + + + 489.75 + + + + 489.87 + + + + 488.95999999999998 + + + + 485.85000000000002 + + + + 482.81 + + + + 481.99000000000001 + + + + 478.92 + + + 476 + + + 474.38 + + + + 474.35000000000002 + + + + 474.12 + + + + 472.52999999999997 + + + + 472.75 + + + + 472.19 + + + + 471.92000000000002 + + + + 471.98000000000002 + + + + 473.49000000000001 + + + + 473.44999999999999 + + + + 473.45999999999998 + + + + 470.27999999999997 + + + + 467.20999999999998 + + + + 466.89999999999998 + + + + 466.76999999999998 + + + + 466.25 + + + + 465.23000000000002 + + + + 464.12 + + + + 463.68000000000001 + + + + 462.5 + + + + 462.45999999999998 + + + + 461.56999999999999 + + + + 461.14999999999998 + + + + 460.19 + + + + 459.83999999999997 + + + + 460.49000000000001 + + + + 460.23000000000002 + + + + 460.56999999999999 + + + + 457.79000000000002 + + + + 454.66000000000003 + + + + + + + #0000FF + + + + 624.7421875 + + + 626.015625 + + + 627.0625 + + + 627.3671875 + + + 626.90234375 + + + 626.11328125 + + + 625.33203125 + + + 623.90625 + + + 623.66796875 + + + 623.71484375 + + + 623.75 + + + 623.9375 + + + 624.1640625 + + + 625.234375 + + + 626 + + + 626.3515625 + + + 626.14453125 + + + 625.6640625 + + + 624.7890625 + + + 623.23046875 + + + 622.09375 + + + 620.9765625 + + + 620.23828125 + + + 619.42578125 + + + 617.7734375 + + + 616.8671875 + + + 616.09765625 + + + 615.87890625 + + + 615.3984375 + + + 614.76953125 + + + 613.47265625 + + + 612.72265625 + + + 612.4609375 + + + 611.85546875 + + + 611.90625 + + + 612.27734375 + + + 613.66796875 + + + 614.62890625 + + + 615.0703125 + + + 614.72265625 + + + 614.26171875 + + + 612.06640625 + + + 609.6875 + + + 606.83984375 + + + 604.671875 + + + 602.52734375 + + + 600.78515625 + + + 598.078125 + + + 597.1953125 + + + 596.5234375 + + + 595.74609375 + + + 594.82421875 + + + 594.10546875 + + + 593.2109375 + + + 592.6875 + + + 592.5390625 + + + 592.7578125 + + + 592.77734375 + + + 592.63671875 + + + 592.06640625 + + + 591.2578125 + + + 590.46875 + + + 589.7578125 + + + 589.359375 + + + 589.05859375 + + + 589.21875 + + + 589.59375 + + + 589.98046875 + + + 589.51953125 + + + 588.796875 + + + 587.4375 + + + 585.70703125 + + + 584.48046875 + + + 583.328125 + + + 582.69921875 + + + 581.96875 + + + 581.3359375 + + + 580.6796875 + + + 580.33984375 + + + 580.0234375 + + + 579.5078125 + + + 578.890625 + + + 578.34375 + + + 577.984375 + + + 577.90234375 + + + 577.50390625 + + + 577.20703125 + + + 576.6171875 + + + 575.82421875 + + + 575.125 + + + 575.0546875 + + + 574.89453125 + + + 574.75 + + + 574.6484375 + + + 574.26953125 + + + 573.72265625 + + + 572.4296875 + + + 570.828125 + + + 570.1015625 + + + 568.7734375 + + + 567.8125 + + + 567.25390625 + + + 567.09765625 + + + 567.1640625 + + + 567.546875 + + + 567.86328125 + + + 568.2890625 + + + 568.49609375 + + + 568.33203125 + + + 566.84765625 + + + 566.609375 + + + 566.94140625 + + + 566.88671875 + + + 566.27734375 + + + 565.48046875 + + + 563.5 + + + 562.51953125 + + + 561.9453125 + + + 561.85546875 + + + 561.7578125 + + + 561.765625 + + + 561.453125 + + + 560.6015625 + + + 559.65234375 + + + 558.7578125 + + + 557.66015625 + + + 556.35546875 + + + 555.2265625 + + + 553.53125 + + + 551.265625 + + + 549.92578125 + + + 549.140625 + + + 548.48828125 + + + 548.0078125 + + + 547.39453125 + + + 547.15234375 + + + 547.08203125 + + + 547.55078125 + + + 548.69921875 + + + 548.76953125 + + + 548.51953125 + + + 547.88671875 + + + 546.7265625 + + + 545.3984375 + + + 543.87890625 + + + 540.6484375 + + + 536.4296875 + + + 536.046875 + + + 535.765625 + + + 535.71875 + + + 535.55859375 + + + 535.359375 + + + 534.5234375 + + + 534.2578125 + + + 535.1328125 + + + 535.46875 + + + 535.04296875 + + + 534.04296875 + + + 532.234375 + + + 530.2109375 + + + 528.7890625 + + + 527.69140625 + + + 526.76171875 + + + 526.1171875 + + + 525.83984375 + + + 525.51171875 + + + 525.34375 + + + 525.18359375 + + + 524.3515625 + + + 524.41015625 + + + 524.47265625 + + + 524.02734375 + + + 523.09375 + + + 521.92578125 + + + 520.87109375 + + + 520.51953125 + + + 520.2578125 + + + 519.6640625 + + + 518.5703125 + + + 517.04296875 + + + 513.03125 + + + 510.19921875 + + + 508.5 + + + 507.8828125 + + + 506.71875 + + + 506.03125 + + + 505.5390625 + + + 504.96875 + + + 504.28125 + + + 503.6640625 + + + 502.578125 + + + 500.921875 + + + 499.85546875 + + + 499.40234375 + + + 498.96875 + + + 497.8828125 + + + 496.2265625 + + + 494.9609375 + + + 494.13671875 + + + 493.6015625 + + + 492.828125 + + + 492.1015625 + + + 491.76953125 + + + 490.83984375 + + + 490.23828125 + + + 489.96484375 + + + 489.703125 + + + 484.7109375 + + + 482.328125 + + + 481.04296875 + + + 480.3046875 + + + 479.70703125 + + + 478.984375 + + + 478.4609375 + + + 479.1015625 + + + 480.359375 + + + 481.19140625 + + + 482.2890625 + + + 483.28125 + + + 483.69921875 + + + 483.4609375 + + + 483.0390625 + + + 481.9140625 + + + 480.515625 + + + 479.16796875 + + + 476.74609375 + + + 474.3515625 + + + 473.28515625 + + + 472.39453125 + + + 471.3671875 + + + 470.0390625 + + + 468.76171875 + + + 467.3671875 + + + 466.60546875 + + + 464.65625 + + + 463.62109375 + + + 462.84375 + + + 462.84765625 + + + + + + #00FF00 + + + + 647.81640625 + + + 646.87109375 + + + 646.1953125 + + + 645.5859375 + + + 644.8203125 + + + 642.9765625 + + + 641.796875 + + + 639.4296875 + + + 636.4921875 + + + 634.1328125 + + + 629.55859375 + + + 627.55078125 + + + 624.0234375 + + + + + + + 663.90234375 + + + 662.74609375 + + + 662.1328125 + + + 661.39453125 + + + 658.98828125 + + + 657.47265625 + + + 654.22265625 + + + 650.0703125 + + + 647.890625 + + + + + + + 421.52999999999997 + + + + 423.57999999999998 + + + + 423 + + + + 423.07999999999998 + + + + 423.02999999999997 + + + + 422.26999999999998 + + + + 421.35000000000002 + + + + 421.75 + + + + 421.48000000000002 + + + + + Index: /trunk/test/data/tracks/tracks-extensions.osm =================================================================== --- /trunk/test/data/tracks/tracks-extensions.osm (revision 15496) +++ /trunk/test/data/tracks/tracks-extensions.osm (revision 15496) @@ -0,0 +1,1741 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /trunk/test/data/tracks/tracks-layerprefs.gpx =================================================================== --- /trunk/test/data/tracks/tracks-layerprefs.gpx (revision 15496) +++ /trunk/test/data/tracks/tracks-layerprefs.gpx (revision 15496) @@ -0,0 +1,1384 @@ + + + + + + + + + + + + + + + + + + + #FF0000 + + + + Segment extension + + + 471.86000000000001 + + + + 471.43000000000001 + + + + 470.69 + + + + 470.94 + + + + 471.5 + + + + 471.67000000000002 + + + + 471.58999999999997 + + + + 472.44999999999999 + + + + 472.54000000000002 + + + + 472.45999999999998 + + + + 471.38 + + + + 471.26999999999998 + + + + 471.36000000000001 + + + + 473.19999999999999 + + + + 475.06 + + + + 474.75 + + + + 474.62 + + + + 474.74000000000001 + + + + 474.06 + + + + 474 + + + + 474.58999999999997 + + + + 474.81999999999999 + + + + 476.29000000000002 + + + + 478.48000000000002 + + + + 481.02999999999997 + + + + 480 + + + + 479.58999999999997 + + + + 478.99000000000001 + + + + 479.58999999999997 + + + + 481.18000000000001 + + + + 481.88 + + + + 483.11000000000001 + + + + 484.49000000000001 + + + + 486.88 + + + + 488.05000000000001 + + + + 487.76999999999998 + + + + 488.95999999999998 + + + + 488.36000000000001 + + + + 488.35000000000002 + + + + 487.19 + + + + 487.63999999999999 + + + + 487.55000000000001 + + + + 488.39999999999998 + + + + 489.18000000000001 + + + + 490.73000000000002 + + + + 491.24000000000001 + + + + 490.25 + + + + 490.00999999999999 + + + + 489.54000000000002 + + + + 489.66000000000003 + + + + 489.06 + + + + 490.08999999999997 + + + + 489.41000000000003 + + + + 489.17000000000002 + + + + 488.87 + + + + 489.37 + + + + 488.94999999999999 + + + + 488.93000000000001 + + + + 488.88999999999999 + + + + 488.86000000000001 + + + + 489.19999999999999 + + + + 489.29000000000002 + + + + 488.95999999999998 + + + + 489.10000000000002 + + + + 492.19 + + + + 492.12 + + + + 493.06999999999999 + + + + 492.58999999999997 + + + + 492.38999999999999 + + + + 492.94 + + + + 492.47000000000003 + + + + 492.50999999999999 + + + + 492.73000000000002 + + + + 492.63 + + + + 493 + + + + 493.00999999999999 + + + + 493.19999999999999 + + + + 493.18000000000001 + + + + 493 + + + + 493.20999999999998 + + + + 493.11000000000001 + + + + 493.30000000000001 + + + + 493.50999999999999 + + + + 493 + + + + 492.37 + + + + 492.30000000000001 + + + + 492.04000000000002 + + + + 491.37 + + + + 491.06999999999999 + + + + 490.39999999999998 + + + + 489.75 + + + + 489.87 + + + + 488.95999999999998 + + + + 485.85000000000002 + + + + 482.81 + + + + 481.99000000000001 + + + + 478.92 + + + 476 + + + 474.38 + + + + 474.35000000000002 + + + + 474.12 + + + + 472.52999999999997 + + + + 472.75 + + + + 472.19 + + + + 471.92000000000002 + + + + 471.98000000000002 + + + + 473.49000000000001 + + + + 473.44999999999999 + + + + 473.45999999999998 + + + + 470.27999999999997 + + + + 467.20999999999998 + + + + 466.89999999999998 + + + + 466.76999999999998 + + + + 466.25 + + + + 465.23000000000002 + + + + 464.12 + + + + 463.68000000000001 + + + + 462.5 + + + + 462.45999999999998 + + + + 461.56999999999999 + + + + 461.14999999999998 + + + + 460.19 + + + + 459.83999999999997 + + + + 460.49000000000001 + + + + 460.23000000000002 + + + + 460.56999999999999 + + + + 457.79000000000002 + + + + 454.66000000000003 + + + + + + + #0000FF + + + + 624.7421875 + + + 626.015625 + + + 627.0625 + + + 627.3671875 + + + 626.90234375 + + + 626.11328125 + + + 625.33203125 + + + 623.90625 + + + 623.66796875 + + + 623.71484375 + + + 623.75 + + + 623.9375 + + + 624.1640625 + + + 625.234375 + + + 626 + + + 626.3515625 + + + 626.14453125 + + + 625.6640625 + + + 624.7890625 + + + 623.23046875 + + + 622.09375 + + + 620.9765625 + + + 620.23828125 + + + 619.42578125 + + + 617.7734375 + + + 616.8671875 + + + 616.09765625 + + + 615.87890625 + + + 615.3984375 + + + 614.76953125 + + + 613.47265625 + + + 612.72265625 + + + 612.4609375 + + + 611.85546875 + + + 611.90625 + + + 612.27734375 + + + 613.66796875 + + + 614.62890625 + + + 615.0703125 + + + 614.72265625 + + + 614.26171875 + + + 612.06640625 + + + 609.6875 + + + 606.83984375 + + + 604.671875 + + + 602.52734375 + + + 600.78515625 + + + 598.078125 + + + 597.1953125 + + + 596.5234375 + + + 595.74609375 + + + 594.82421875 + + + 594.10546875 + + + 593.2109375 + + + 592.6875 + + + 592.5390625 + + + 592.7578125 + + + 592.77734375 + + + 592.63671875 + + + 592.06640625 + + + 591.2578125 + + + 590.46875 + + + 589.7578125 + + + 589.359375 + + + 589.05859375 + + + 589.21875 + + + 589.59375 + + + 589.98046875 + + + 589.51953125 + + + 588.796875 + + + 587.4375 + + + 585.70703125 + + + 584.48046875 + + + 583.328125 + + + 582.69921875 + + + 581.96875 + + + 581.3359375 + + + 580.6796875 + + + 580.33984375 + + + 580.0234375 + + + 579.5078125 + + + 578.890625 + + + 578.34375 + + + 577.984375 + + + 577.90234375 + + + 577.50390625 + + + 577.20703125 + + + 576.6171875 + + + 575.82421875 + + + 575.125 + + + 575.0546875 + + + 574.89453125 + + + 574.75 + + + 574.6484375 + + + 574.26953125 + + + 573.72265625 + + + 572.4296875 + + + 570.828125 + + + 570.1015625 + + + 568.7734375 + + + 567.8125 + + + 567.25390625 + + + 567.09765625 + + + 567.1640625 + + + 567.546875 + + + 567.86328125 + + + 568.2890625 + + + 568.49609375 + + + 568.33203125 + + + 566.84765625 + + + 566.609375 + + + 566.94140625 + + + 566.88671875 + + + 566.27734375 + + + 565.48046875 + + + 563.5 + + + 562.51953125 + + + 561.9453125 + + + 561.85546875 + + + 561.7578125 + + + 561.765625 + + + 561.453125 + + + 560.6015625 + + + 559.65234375 + + + 558.7578125 + + + 557.66015625 + + + 556.35546875 + + + 555.2265625 + + + 553.53125 + + + 551.265625 + + + 549.92578125 + + + 549.140625 + + + 548.48828125 + + + 548.0078125 + + + 547.39453125 + + + 547.15234375 + + + 547.08203125 + + + 547.55078125 + + + 548.69921875 + + + 548.76953125 + + + 548.51953125 + + + 547.88671875 + + + 546.7265625 + + + 545.3984375 + + + 543.87890625 + + + 540.6484375 + + + 536.4296875 + + + 536.046875 + + + 535.765625 + + + 535.71875 + + + 535.55859375 + + + 535.359375 + + + 534.5234375 + + + 534.2578125 + + + 535.1328125 + + + 535.46875 + + + 535.04296875 + + + 534.04296875 + + + 532.234375 + + + 530.2109375 + + + 528.7890625 + + + 527.69140625 + + + 526.76171875 + + + 526.1171875 + + + 525.83984375 + + + 525.51171875 + + + 525.34375 + + + 525.18359375 + + + 524.3515625 + + + 524.41015625 + + + 524.47265625 + + + 524.02734375 + + + 523.09375 + + + 521.92578125 + + + 520.87109375 + + + 520.51953125 + + + 520.2578125 + + + 519.6640625 + + + 518.5703125 + + + 517.04296875 + + + 513.03125 + + + 510.19921875 + + + 508.5 + + + 507.8828125 + + + 506.71875 + + + 506.03125 + + + 505.5390625 + + + 504.96875 + + + 504.28125 + + + 503.6640625 + + + 502.578125 + + + 500.921875 + + + 499.85546875 + + + 499.40234375 + + + 498.96875 + + + 497.8828125 + + + 496.2265625 + + + 494.9609375 + + + 494.13671875 + + + 493.6015625 + + + 492.828125 + + + 492.1015625 + + + 491.76953125 + + + 490.83984375 + + + 490.23828125 + + + 489.96484375 + + + 489.703125 + + + 484.7109375 + + + 482.328125 + + + 481.04296875 + + + 480.3046875 + + + 479.70703125 + + + 478.984375 + + + 478.4609375 + + + 479.1015625 + + + 480.359375 + + + 481.19140625 + + + 482.2890625 + + + 483.28125 + + + 483.69921875 + + + 483.4609375 + + + 483.0390625 + + + 481.9140625 + + + 480.515625 + + + 479.16796875 + + + 476.74609375 + + + 474.3515625 + + + 473.28515625 + + + 472.39453125 + + + 471.3671875 + + + 470.0390625 + + + 468.76171875 + + + 467.3671875 + + + 466.60546875 + + + 464.65625 + + + 463.62109375 + + + 462.84375 + + + 462.84765625 + + + + + + #00FF00 + + + + 647.81640625 + + + 646.87109375 + + + 646.1953125 + + + 645.5859375 + + + 644.8203125 + + + 642.9765625 + + + 641.796875 + + + 639.4296875 + + + 636.4921875 + + + 634.1328125 + + + 629.55859375 + + + 627.55078125 + + + 624.0234375 + + + + + + #FFCC00 + + + + 663.90234375 + + + 662.74609375 + + + 662.1328125 + + + 661.39453125 + + + 658.98828125 + + + 657.47265625 + + + 654.22265625 + + + 650.0703125 + + + 647.890625 + + + + + + + 421.52999999999997 + + + + 423.57999999999998 + + + + 423 + + + + 423.07999999999998 + + + + 423.02999999999997 + + + + 422.26999999999998 + + + + 421.35000000000002 + + + + 421.75 + + + + 421.48000000000002 + + + + + Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java (revision 15496) @@ -36,4 +36,5 @@ import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; /** @@ -64,5 +65,5 @@ @Test public void testMergeFrom() { - ImmutableGpxTrack track = singleWaypointGpxTrack(); + GpxTrack track = singleWaypointGpxTrack(); GpxRoute route = singleWaypointRoute(); WayPoint newWP = new WayPoint(LatLon.NORTH_POLE); @@ -103,5 +104,7 @@ final GpxData expected = getGpx(exp); own.mergeFrom(other, cut, connect); - assertEquals(expected, own); + own.put(GpxConstants.META_BOUNDS, null); + expected.put(GpxConstants.META_BOUNDS, null); //they are only updated by GpxWriter + assertEquals(exp + " didn't match!", expected, own); } @@ -117,6 +120,6 @@ assertEquals(0, data.getTracks().size()); - ImmutableGpxTrack track1 = emptyGpxTrack(); - ImmutableGpxTrack track2 = singleWaypointGpxTrack(); + GpxTrack track1 = emptyGpxTrack(); + GpxTrack track2 = singleWaypointGpxTrack(); data.addTrack(track1); assertEquals(1, data.getTracks().size()); @@ -137,5 +140,5 @@ @Test(expected = IllegalArgumentException.class) public void testAddTrackFails() { - ImmutableGpxTrack track1 = emptyGpxTrack(); + GpxTrack track1 = emptyGpxTrack(); data.addTrack(track1); data.addTrack(track1); @@ -147,5 +150,5 @@ @Test(expected = IllegalArgumentException.class) public void testRemoveTrackFails() { - ImmutableGpxTrack track1 = emptyGpxTrack(); + GpxTrack track1 = emptyGpxTrack(); data.addTrack(track1); data.removeTrack(track1); @@ -246,8 +249,8 @@ public void testHasTrackPoints() { assertFalse(data.hasTrackPoints()); - ImmutableGpxTrack track1 = emptyGpxTrack(); + GpxTrack track1 = emptyGpxTrack(); data.addTrack(track1); assertFalse(data.hasTrackPoints()); - ImmutableGpxTrack track2 = singleWaypointGpxTrack(); + GpxTrack track2 = singleWaypointGpxTrack(); data.addTrack(track2); assertTrue(data.hasTrackPoints()); @@ -260,8 +263,8 @@ public void testGetTrackPoints() { assertEquals(0, data.getTrackPoints().count()); - ImmutableGpxTrack track1 = singleWaypointGpxTrack(); + GpxTrack track1 = singleWaypointGpxTrack(); data.addTrack(track1); assertEquals(1, data.getTrackPoints().count()); - ImmutableGpxTrack track2 = singleWaypointGpxTrack(); + GpxTrack track2 = singleWaypointGpxTrack(); data.addTrack(track2); assertEquals(2, data.getTrackPoints().count()); @@ -281,5 +284,5 @@ @Test public void testIsEmpty() { - ImmutableGpxTrack track1 = singleWaypointGpxTrack(); + GpxTrack track1 = singleWaypointGpxTrack(); WayPoint waypoint = new WayPoint(LatLon.ZERO); GpxRoute route = singleWaypointRoute(); @@ -308,9 +311,9 @@ @Test public void testLength() { - ImmutableGpxTrack track1 = waypointGpxTrack( + GpxTrack track1 = waypointGpxTrack( new WayPoint(new LatLon(0, 0)), new WayPoint(new LatLon(1, 1)), new WayPoint(new LatLon(0, 2))); - ImmutableGpxTrack track2 = waypointGpxTrack( + GpxTrack track2 = waypointGpxTrack( new WayPoint(new LatLon(0, 0)), new WayPoint(new LatLon(-1, 1))); @@ -336,6 +339,6 @@ p2.setTime(new Date(100020)); p4.setTime(new Date(500020)); - data.addTrack(new ImmutableGpxTrack(Arrays.asList(Arrays.asList(p1, p2)), Collections.emptyMap())); - data.addTrack(new ImmutableGpxTrack(Arrays.asList(Arrays.asList(p3, p4, p5)), Collections.emptyMap())); + data.addTrack(new GpxTrack(Arrays.asList(Arrays.asList(p1, p2)), Collections.emptyMap())); + data.addTrack(new GpxTrack(Arrays.asList(Arrays.asList(p3, p4, p5)), Collections.emptyMap())); Date[] times = data.getMinMaxTimeForAllTracks(); @@ -355,5 +358,5 @@ .map(WayPoint::new) .collect(Collectors.toList()); - data.addTrack(new ImmutableGpxTrack(Arrays.asList(points), Collections.emptyMap())); + data.addTrack(new GpxTrack(Arrays.asList(points), Collections.emptyMap())); WayPoint closeToMiddle = data.nearestPointOnTrack(new EastNorth(10, 0), 10); @@ -449,14 +452,14 @@ } - private static ImmutableGpxTrack emptyGpxTrack() { - return new ImmutableGpxTrack(Collections.>emptyList(), Collections.emptyMap()); - } - - private static ImmutableGpxTrack singleWaypointGpxTrack() { - return new ImmutableGpxTrack(Collections.singleton(Collections.singleton(new WayPoint(LatLon.ZERO))), Collections.emptyMap()); - } - - private static ImmutableGpxTrack waypointGpxTrack(WayPoint... wps) { - return new ImmutableGpxTrack(Collections.singleton(Arrays.asList(wps)), Collections.emptyMap()); + private static GpxTrack emptyGpxTrack() { + return new GpxTrack(Collections.>emptyList(), Collections.emptyMap()); + } + + private static GpxTrack singleWaypointGpxTrack() { + return new GpxTrack(Collections.singleton(Collections.singleton(new WayPoint(LatLon.ZERO))), Collections.emptyMap()); + } + + private static GpxTrack waypointGpxTrack(WayPoint... wps) { + return new GpxTrack(Collections.singleton(Arrays.asList(wps)), Collections.emptyMap()); } @@ -473,8 +476,12 @@ public void testEqualsContract() { TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); EqualsVerifier.forClass(GpxData.class).usingGetClass() - .withIgnoredFields("attr", "creator", "fromServer", "storageFile", "listeners", "tracks", "routes", "waypoints", "proxy", "segSpans") + .suppress(Warning.NONFINAL_FIELDS) + .withIgnoredFields("creator", "fromServer", "storageFile", "initializing", "updating", "suppressedInvalidate", "listeners", "tracks", "routes", "waypoints", "proxy", "segSpans", "modified") .withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE)) .withPrefabValues(ListenerList.class, ListenerList.create(), ListenerList.create()) + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) .verify(); } Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxExtensionTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxExtensionTest.java (revision 15496) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxExtensionTest.java (revision 15496) @@ -0,0 +1,46 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import org.junit.Rule; +import org.junit.Test; +import org.openstreetmap.josm.TestUtils; +import org.openstreetmap.josm.gui.layer.gpx.ConvertToDataLayerActionTest; +import org.openstreetmap.josm.io.GpxReaderTest; +import org.openstreetmap.josm.io.GpxWriterTest; +import org.openstreetmap.josm.testutils.JOSMTestRules; + +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; + +/** + * Unit tests for class {@link GpxExtension} + */ +public class GpxExtensionTest { + + /** + * Setup test. + */ + @Rule + @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") + public JOSMTestRules test = new JOSMTestRules(); + + /** + * Unit test of methods {@link GpxExtension#equals} and {@link GpxExtension#hashCode}. + * @see GpxWriterTest#testExtensions() + * @see GpxReaderTest#testLayerPrefs() + * @see ConvertToDataLayerActionTest#testFromTrack() + */ + @Test + public void testEqualsContract() { + TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); + EqualsVerifier.forClass(GpxExtension.class).usingGetClass() + .suppress(Warning.NONFINAL_FIELDS) + .withIgnoredFields("qualifiedName") + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) + .verify(); + } + +} Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxRouteTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxRouteTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxRouteTest.java (revision 15496) @@ -30,7 +30,10 @@ public void testEqualsContract() { TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); EqualsVerifier.forClass(GpxRoute.class).usingGetClass() .suppress(Warning.NONFINAL_FIELDS) .withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE)) + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) .verify(); } Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackSegmentTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackSegmentTest.java (revision 15496) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackSegmentTest.java (revision 15496) @@ -0,0 +1,41 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import org.junit.Rule; +import org.junit.Test; +import org.openstreetmap.josm.TestUtils; +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.testutils.JOSMTestRules; + +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; + +/** + * Unit tests for class {@link GpxTrackSegment}. + */ +public class GpxTrackSegmentTest { + + /** + * Setup test. + */ + @Rule + @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") + public JOSMTestRules test = new JOSMTestRules(); + + /** + * Unit test of methods {@link GpxTrackSegment#equals} and {@link GpxTrackSegment#hashCode}. + */ + @Test + public void testEqualsContract() { + TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); + EqualsVerifier.forClass(GpxTrackSegment.class).usingGetClass() + .suppress(Warning.NONFINAL_FIELDS) + .withIgnoredFields("bounds", "length") + .withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE)) + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) + .verify(); + } +} Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackTest.java (revision 15496) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTrackTest.java (revision 15496) @@ -0,0 +1,74 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.gpx; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import java.awt.Color; +import java.util.ArrayList; +import java.util.HashMap; + +import org.junit.Rule; +import org.junit.Test; +import org.openstreetmap.josm.TestUtils; +import org.openstreetmap.josm.testutils.JOSMTestRules; +import org.openstreetmap.josm.tools.ListenerList; + +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; + +/** + * Unit tests for class {@link GpxTrack}. + */ +public class GpxTrackTest { + + /** + * Setup test. + */ + @Rule + @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") + public JOSMTestRules test = new JOSMTestRules(); + + /** + * Tests weather the track can read and write colors. + */ + @Test + public void testColors() { + GpxTrack trk = new GpxTrack(new ArrayList(), new HashMap<>()); + GpxExtensionCollection ext = trk.getExtensions(); + ext.add("gpxd", "color", "#FF0000"); + trk.invalidate(); + assertEquals(trk.getColor(), Color.RED); + trk.setColor(Color.GREEN); + assertEquals(trk.getColor(), Color.GREEN); + trk.invalidate(); + assertEquals(trk.getColor(), Color.GREEN); + ext.remove("gpxd", "color"); + trk.invalidate(); + assertNull(trk.getColor()); + ext.add("gpxx", "TrackExtensions").getExtensions().add("gpxx", "DisplayColor", "Blue"); + trk.invalidate(); + assertEquals(trk.getColor(), Color.BLUE); + trk.setColor(null); + assertNull(trk.getColor()); + trk.invalidate(); + assertNull(trk.getColor()); + } + + /** + * Unit test of methods {@link GpxTrack#equals} and {@link GpxTrack#hashCode}. + */ + @Test + public void testEqualsContract() { + TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); + EqualsVerifier.forClass(GpxTrack.class).usingGetClass() + .suppress(Warning.NONFINAL_FIELDS) + .withPrefabValues(ListenerList.class, ListenerList.create(), ListenerList.create()) + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) + .withIgnoredFields("bounds", "length", "colorCache", "colorFormat", "listeners") + .verify(); + } +} Index: unk/test/unit/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegmentTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegmentTest.java (revision 15495) +++ (revision ) @@ -1,36 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.data.gpx; - -import org.junit.Rule; -import org.junit.Test; -import org.openstreetmap.josm.TestUtils; -import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.testutils.JOSMTestRules; - -import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; -import nl.jqno.equalsverifier.EqualsVerifier; - -/** - * Unit tests for class {@link ImmutableGpxTrackSegment}. - */ -public class ImmutableGpxTrackSegmentTest { - - /** - * Setup test. - */ - @Rule - @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") - public JOSMTestRules test = new JOSMTestRules(); - - /** - * Unit test of methods {@link ImmutableGpxTrackSegment#equals} and {@link ImmutableGpxTrackSegment#hashCode}. - */ - @Test - public void testEqualsContract() { - TestUtils.assumeWorkingEqualsVerifier(); - EqualsVerifier.forClass(ImmutableGpxTrackSegment.class).usingGetClass() - .withIgnoredFields("bounds", "length") - .withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE)) - .verify(); - } -} Index: unk/test/unit/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackTest.java (revision 15495) +++ (revision ) @@ -1,36 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.data.gpx; - -import org.junit.Rule; -import org.junit.Test; -import org.openstreetmap.josm.TestUtils; -import org.openstreetmap.josm.testutils.JOSMTestRules; - -import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; -import nl.jqno.equalsverifier.EqualsVerifier; -import nl.jqno.equalsverifier.Warning; - -/** - * Unit tests for class {@link ImmutableGpxTrack}. - */ -public class ImmutableGpxTrackTest { - - /** - * Setup test. - */ - @Rule - @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") - public JOSMTestRules test = new JOSMTestRules(); - - /** - * Unit test of methods {@link ImmutableGpxTrack#equals} and {@link ImmutableGpxTrack#hashCode}. - */ - @Test - public void testEqualsContract() { - TestUtils.assumeWorkingEqualsVerifier(); - EqualsVerifier.forClass(ImmutableGpxTrack.class).usingGetClass() - .suppress(Warning.NONFINAL_FIELDS) - .withIgnoredFields("bounds", "length") - .verify(); - } -} Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/WayPointTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/WayPointTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/WayPointTest.java (revision 15496) @@ -29,7 +29,10 @@ public void testEqualsContract() { TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); EqualsVerifier.forClass(WayPoint.class).usingGetClass() .suppress(Warning.NONFINAL_FIELDS) .withIgnoredFields("customColoring", "dir", "drawLine", "east", "north", "eastNorthCacheKey") + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) .verify(); } Index: /trunk/test/unit/org/openstreetmap/josm/data/gpx/WithAttributesTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/data/gpx/WithAttributesTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/data/gpx/WithAttributesTest.java (revision 15496) @@ -29,6 +29,9 @@ public void testEqualsContract() { TestUtils.assumeWorkingEqualsVerifier(); + GpxExtensionCollection col = new GpxExtensionCollection(); + col.add("josm", "from-server", "true"); EqualsVerifier.forClass(WithAttributes.class).usingGetClass() .suppress(Warning.NONFINAL_FIELDS) + .withPrefabValues(GpxExtensionCollection.class, new GpxExtensionCollection(), col) .verify(); } Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/GpxLayerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/GpxLayerTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/GpxLayerTest.java (revision 15496) @@ -4,4 +4,5 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; @@ -19,5 +20,6 @@ import org.openstreetmap.josm.TestUtils; import org.openstreetmap.josm.data.gpx.GpxData; -import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrack; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.DataSet; @@ -74,13 +76,17 @@ public void testGpxLayer() throws Exception { GpxLayer layer = new GpxLayer(new GpxData(), "foo", false); + GpxTrack trk = new GpxTrack(new ArrayList(), new HashMap<>()); + trk.getExtensions().add("gpxd", "color", "#FF0000"); + layer.data.addTrack(trk); + assertEquals("foo", layer.getName()); assertFalse(layer.isLocalFile()); - assertEquals(Color.MAGENTA, layer.getColorProperty().get()); - assertEquals("0 tracks (0 segments), 0 routes, 0 waypoints
Length: < 0.01 m
", layer.getToolTipText()); + assertEquals(layer.getColor(), Color.RED); + assertEquals("1 track (0 segments), 0 routes, 0 waypoints
Length: < 0.01 m
", layer.getToolTipText()); GpxLayer layer2 = new GpxLayer(new GpxData(), "bar", true); assertEquals("bar", layer2.getName()); assertTrue(layer2.isLocalFile()); - assertEquals(Color.MAGENTA, layer2.getColorProperty().get()); + assertNull(layer2.getColor()); assertEquals("0 tracks (0 segments), 0 routes, 0 waypoints
Length: < 0.01 m
", layer2.getToolTipText()); @@ -188,5 +194,5 @@ public void testGetTimespanForTrack() throws Exception { assertEquals("", GpxLayer.getTimespanForTrack( - new ImmutableGpxTrack(new ArrayList>(), new HashMap()))); + new GpxTrack(new ArrayList>(), new HashMap()))); assertEquals("1/3/16 11:59 AM - 12:00 PM (0:00)", GpxLayer.getTimespanForTrack(getMinimalGpxData().tracks.iterator().next())); Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/LayerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/LayerTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/LayerTest.java (revision 15496) @@ -8,5 +8,4 @@ import static org.junit.Assert.assertTrue; -import java.awt.Color; import java.io.File; @@ -14,6 +13,4 @@ import org.junit.Rule; import org.junit.Test; -import org.openstreetmap.josm.data.preferences.AbstractProperty; -import org.openstreetmap.josm.data.preferences.NamedColorProperty; import org.openstreetmap.josm.data.projection.ProjectionRegistry; import org.openstreetmap.josm.testutils.JOSMTestRules; @@ -41,23 +38,4 @@ public void setUp() { testLayer = new LayerManagerTest.TestLayer(); - } - - /** - * Test {@link Layer#getColorProperty()} - */ - @Test - public void testGetColorProperty() { - assertEquals(null, testLayer.getColorProperty()); - - AbstractProperty color = new LayerManagerTest.TestLayer() { - @Override - protected NamedColorProperty getBaseColorProperty() { - return new NamedColorProperty("x", Color.BLACK); - } - }.getColorProperty(); - - assertEquals(Color.BLACK, color.get()); - assertEquals(Color.BLACK, color.getDefaultValue()); - assertEquals("clr.layer.Test Layer.x", color.getKey()); } @@ -98,10 +76,5 @@ assertEquals("Test Layer2", testLayer.getName()); - testLayer = new LayerManagerTest.TestLayer() { - @Override - public AbstractProperty getColorProperty() { - return new NamedColorProperty("test", Color.RED); - } - }; + testLayer = new LayerManagerTest.TestLayer(); testLayer.setName("Test Layer2"); Index: unk/test/unit/org/openstreetmap/josm/gui/layer/MarkerLayerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/MarkerLayerTest.java (revision 15495) +++ (revision ) @@ -1,49 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.gui.layer; - -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; - -import org.junit.Rule; -import org.junit.Test; -import org.openstreetmap.josm.data.gpx.GpxData; -import org.openstreetmap.josm.data.osm.DataSet; -import org.openstreetmap.josm.gui.MainApplication; -import org.openstreetmap.josm.gui.MapFrame; -import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer; -import org.openstreetmap.josm.testutils.JOSMTestRules; - -import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; - -/** - * Unit tests of {@link MarkerLayer} class. - */ -public class MarkerLayerTest { - - /** - * For creating layers - */ - @Rule - @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") - public JOSMTestRules test = new JOSMTestRules().main().projection(); - - /** - * Unit test of {@code Main.map.mapView.playHeadMarker}. - */ - @Test - public void testPlayHeadMarker() { - try { - MainApplication.getLayerManager().addLayer(new OsmDataLayer(new DataSet(), "", null)); - MapFrame map = MainApplication.getMap(); - MarkerLayer layer = new MarkerLayer(new GpxData(), null, null, null); - assertNull(map.mapView.playHeadMarker); - MainApplication.getLayerManager().addLayer(layer); - assertNotNull(map.mapView.playHeadMarker); - MainApplication.getLayerManager().removeLayer(layer); - } finally { - if (MainApplication.isDisplayingMapView()) { - MainApplication.getMap().mapView.playHeadMarker = null; - } - } - } -} Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/OsmDataLayerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/OsmDataLayerTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/OsmDataLayerTest.java (revision 15496) @@ -24,5 +24,5 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.data.osm.DataSet; @@ -241,5 +241,5 @@ assertEquals(1, gpx.getTrackCount()); GpxTrack track = gpx.getTracks().iterator().next(); - Collection segments = track.getSegments(); + Collection segments = track.getSegments(); assertEquals(1, segments.size()); Collection trackpoints = segments.iterator().next().getWayPoints(); Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityActionTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityActionTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityActionTest.java (revision 15496) @@ -39,13 +39,13 @@ @Override protected String getString(final ExtendedDialog instance) { - return ((JLabel) ((JPanel) this.getContent(instance)).getComponent(2)).getText(); + return ((JLabel) ((JPanel) instance.getContentPane().getComponent(0)).getComponent(2)).getText(); } }; edMocker.getMockResultMap().put( - "Select all tracks that you want to be displayed. You can drag select a range of " + - "tracks or use CTRL+Click to select specific ones. The map is updated live in the " + - "background. Open the URLs by double clicking them.", - "Show all" - ); + "Select all tracks that you want to be displayed. " + + "You can drag select a range of tracks or use CTRL+Click to select specific ones. " + + "The map is updated live in the background. Open the URLs by double clicking them, edit name and description by double clicking the cell.", + "Show all" + ); new ChooseTrackVisibilityAction(GpxLayerTest.getMinimalGpxLayer()).actionPerformed(null); @@ -53,5 +53,5 @@ assertEquals(1, edMocker.getInvocationLog().size()); Object[] invocationLogEntry = edMocker.getInvocationLog().get(0); - assertEquals(1, (int) invocationLogEntry[0]); + assertEquals(2, (int) invocationLogEntry[0]); assertEquals("Set track visibility for Bananas", invocationLogEntry[2]); } Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerActionTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerActionTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerActionTest.java (revision 15496) @@ -67,18 +67,31 @@ public void testFromTrack() throws Exception { Config.getPref().put("gpx.convert-tags", "no"); - testFromTrack("tracks"); + testFromTrack("tracks.gpx", "tracks.osm"); Config.getPref().put("gpx.convert-tags", "yes"); - testFromTrack("tracks-ele-time"); + testFromTrack("tracks.gpx", "tracks-ele-time.osm"); Config.getPref().put("gpx.convert-tags", "list"); Config.getPref().putList("gpx.convert-tags.list.yes", Arrays.asList("ele")); Config.getPref().putList("gpx.convert-tags.list.no", Arrays.asList("time")); - testFromTrack("tracks-ele"); - + testFromTrack("tracks.gpx", "tracks-ele.osm"); Config.getPref().putList("gpx.convert-tags.list.yes", Arrays.asList("time")); Config.getPref().putList("gpx.convert-tags.list.no", Arrays.asList("ele")); - testFromTrack("tracks-time"); + testFromTrack("tracks.gpx", "tracks-time.osm"); + + //Extension tests: + Config.getPref().put("gpx.convert-tags", "yes"); + testFromTrack("tracks-extensions.gpx", "tracks-extensions.osm"); + + Config.getPref().put("gpx.convert-tags", "list"); + Config.getPref().putList("gpx.convert-tags.list.yes", Arrays.asList("time", "ele")); + Config.getPref().putList("gpx.convert-tags.list.no", Arrays.asList( + "gpxx:DisplayColor", + "gpxd:color", + "gpx:extension:test:tag", + "gpx:extension:test:segment:tag")); + testFromTrack("tracks-extensions.gpx", "tracks-ele-time.osm"); + } @@ -107,11 +120,11 @@ } - private void testFromTrack(String expected) throws IOException, SAXException, IllegalDataException { - final GpxData data = GpxReaderTest.parseGpxData(TestUtils.getTestDataRoot() + "tracks/tracks.gpx"); + private void testFromTrack(String originalGpx, String expectedOsm) throws IOException, SAXException, IllegalDataException { + final GpxData data = GpxReaderTest.parseGpxData(TestUtils.getTestDataRoot() + "tracks/" + originalGpx); final DataSet osmExpected = OsmReader.parseDataSet(Files.newInputStream( - Paths.get(TestUtils.getTestDataRoot(), "tracks/" + expected + ".osm")), null); + Paths.get(TestUtils.getTestDataRoot(), "tracks/" + expectedOsm)), null); final GpxLayer layer = new GpxLayer(data); final DataSet osm = new ConvertFromGpxLayerAction(layer).convert(); - //compare sorted coordinates/tags and total amount of primitives, because IDs and order will vary after reload + //compare sorted nodes/ways, tags and total amount of primitives, because IDs and order will vary after reload List nodes = osm.getNodes().stream() @@ -125,6 +138,19 @@ .collect(Collectors.toList()); - assertEquals(nodesExpected, nodes); - assertEquals(osmExpected.allPrimitives().size(), osm.allPrimitives().size()); + assertEquals("Conversion " + originalGpx + " -> " + expectedOsm + " didn't match!", nodesExpected, nodes); + + List ways = osm.getWays().stream() + .map(w -> Integer.toString(w.getNodes().size()) + ":" + w.getKeys().entrySet().stream().sorted((e1, e2) -> e1.getKey().compareTo(e2.getKey())).collect(Collectors.toList()).toString()) + .sorted() + .collect(Collectors.toList()); + + List waysExpected = osmExpected.getWays().stream() + .map(w -> Integer.toString(w.getNodes().size()) + ":" + w.getKeys().entrySet().stream().sorted((e1, e2) -> e1.getKey().compareTo(e2.getKey())).collect(Collectors.toList()).toString()) + .sorted() + .collect(Collectors.toList()); + + assertEquals("Conversion " + originalGpx + " -> " + expectedOsm + " didn't match!", waysExpected, ways); + + assertEquals("Conversion " + originalGpx + " -> " + expectedOsm + " didn't match!", osmExpected.allPrimitives().size(), osm.allPrimitives().size()); } Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelperTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelperTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelperTest.java (revision 15496) @@ -7,4 +7,5 @@ import java.io.IOException; import java.util.List; +import java.util.Map; import java.util.stream.Collectors; @@ -14,9 +15,11 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.gui.layer.GpxLayer; +import org.openstreetmap.josm.gui.layer.gpx.GpxDrawHelper.ColorMode; import org.openstreetmap.josm.io.GpxReaderTest; -import org.openstreetmap.josm.spi.preferences.Config; import org.openstreetmap.josm.testutils.JOSMTestRules; import org.openstreetmap.josm.tools.ColorHelper; import org.xml.sax.SAXException; + +import com.google.common.collect.ImmutableMap; import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; @@ -42,8 +45,9 @@ @Test public void testTicket12312() throws FileNotFoundException, IOException, SAXException { - Config.getPref().putBoolean("draw.rawgps.colors.dynamic.layer 12312", true); - Config.getPref().putInt("draw.rawgps.colors.layer 12312", GpxDrawHelper.ColorMode.VELOCITY.toIndex()); - final List colors = calculateColors(TestUtils.getRegressionDataFile(12312, "single_trackpoint.gpx"), "12312", 1); - assertEquals("[#FF00FF]", colors.toString()); + final List colors = calculateColors(TestUtils.getRegressionDataFile(12312, "single_trackpoint.gpx"), + ImmutableMap.of("colormode.dynamic-range", "true", + "colormode", Integer.toString(ColorMode.VELOCITY.toIndex())), + 1); + assertEquals("[null]", colors.toString()); } @@ -56,6 +60,6 @@ @Test public void testNone() throws IOException, SAXException { - final List colors = calculateColors("data_nodist/2094047.gpx", "000", 10); - assertEquals("[#FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF, #FF00FF]", colors.toString()); + final List colors = calculateColors("data_nodist/2094047.gpx", ImmutableMap.of(), 10); + assertEquals("[#000000, #000000, #000000, #000000, #000000, #000000, #000000, #000000, #000000, #000000]", colors.toString()); } @@ -68,7 +72,6 @@ @Test public void testVelocity() throws IOException, SAXException { - Config.getPref().putInt("draw.rawgps.colors.layer 001", GpxDrawHelper.ColorMode.VELOCITY.toIndex()); - final List colors = calculateColors("data_nodist/2094047.gpx", "001", 10); - assertEquals("[#FF00FF, #FFAD00, #FFA800, #FFA800, #FF9E00, #FF9400, #FF7000, #FF7000, #FF8000, #FF9400]", colors.toString()); + final List colors = calculateColors("data_nodist/2094047.gpx", ImmutableMap.of("colormode", Integer.toString(ColorMode.VELOCITY.toIndex())), 10); + assertEquals("[#000000, #FFAD00, #FFA800, #FFA800, #FF9E00, #FF9400, #FF7000, #FF7000, #FF8000, #FF9400]", colors.toString()); } @@ -81,8 +84,9 @@ @Test public void testVelocityDynamic() throws IOException, SAXException { - Config.getPref().putInt("draw.rawgps.colors.layer 002", GpxDrawHelper.ColorMode.VELOCITY.toIndex()); - Config.getPref().putBoolean("draw.rawgps.colors.dynamic.layer 002", true); - final List colors = calculateColors("data_nodist/2094047.gpx", "002", 10); - assertEquals("[#FF00FF, #00FFE0, #00FFC2, #00FFC2, #00FF75, #00FF3D, #99FF00, #94FF00, #38FF00, #00FF38]", colors.toString()); + final List colors = calculateColors("data_nodist/2094047.gpx", + ImmutableMap.of("colormode.dynamic-range", "true", + "colormode", Integer.toString(ColorMode.VELOCITY.toIndex())), + 10); + assertEquals("[#000000, #00FFE0, #00FFC2, #00FFC2, #00FF75, #00FF3D, #99FF00, #94FF00, #38FF00, #00FF38]", colors.toString()); } @@ -95,7 +99,6 @@ @Test public void testDirection() throws IOException, SAXException { - Config.getPref().putInt("draw.rawgps.colors.layer 003", GpxDrawHelper.ColorMode.DIRECTION.toIndex()); - final List colors = calculateColors("data_nodist/2094047.gpx", "003", 10); - assertEquals("[#FF00FF, #EAEC25, #EDEA26, #EDE525, #ECD322, #EBB81D, #E85A0D, #E73708, #E84D0B, #EA8A15]", colors.toString()); + final List colors = calculateColors("data_nodist/2094047.gpx", ImmutableMap.of("colormode", Integer.toString(ColorMode.DIRECTION.toIndex())), 10); + assertEquals("[#000000, #EAEC25, #EDEA26, #EDE525, #ECD322, #EBB81D, #E85A0D, #E73708, #E84D0B, #EA8A15]", colors.toString()); } @@ -108,7 +111,6 @@ @Test public void testTime() throws IOException, SAXException { - Config.getPref().putInt("draw.rawgps.colors.layer 003", GpxDrawHelper.ColorMode.TIME.toIndex()); - final List colors = calculateColors("data_nodist/2094047.gpx", "003", 10); - assertEquals("[#FF00FF, #FF0000, #FF0000, #FF0500, #FF0500, #FF0A00, #FF0A00, #FF1F00, #FF2E00, #FF3300]", colors.toString()); + final List colors = calculateColors("data_nodist/2094047.gpx", ImmutableMap.of("colormode", Integer.toString(ColorMode.TIME.toIndex())), 10); + assertEquals("[#000000, #FF0000, #FF0000, #FF0500, #FF0500, #FF0A00, #FF0A00, #FF1F00, #FF2E00, #FF3300]", colors.toString()); } @@ -116,5 +118,5 @@ * * @param fileName the GPX filename to parse - * @param layerName the layer name used to fetch the color settings, see {@link GpxDrawHelper#readPreferences(java.lang.String)} + * @param layerPrefs a HashMap representing the layer specific preferences * @param n the number of waypoints of the first track/segment to analyze * @return the HTML color codes for the first {@code n} points @@ -123,9 +125,10 @@ * @throws SAXException if any SAX error occurs */ - static List calculateColors(String fileName, String layerName, int n) throws IOException, SAXException { + static List calculateColors(String fileName, Map layerPrefs, int n) throws IOException, SAXException { final GpxData data = GpxReaderTest.parseGpxData(fileName); + data.getLayerPrefs().putAll(layerPrefs); final GpxLayer layer = new GpxLayer(data); final GpxDrawHelper gdh = new GpxDrawHelper(layer); - gdh.readPreferences(layerName); + gdh.readPreferences(); gdh.calculateColors(); return data.getTrackPoints().limit(n).map(p -> ColorHelper.color2html(p.customColoring)).collect(Collectors.toList()); Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarkerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarkerTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarkerTest.java (revision 15496) @@ -11,6 +11,4 @@ import org.openstreetmap.josm.JOSMFixture; import org.openstreetmap.josm.data.coor.LatLon; -import org.openstreetmap.josm.data.gpx.Extensions; -import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.WayPoint; @@ -46,6 +44,5 @@ WayPoint wpt = marker.convertToWayPoint(); assertEquals(LatLon.ZERO, wpt.getCoor()); - Extensions ext = (Extensions) wpt.get(GpxConstants.META_EXTENSIONS); - assertEquals("2.0", ext.get("offset")); + assertEquals("2.0", wpt.getExtensions().get("josm", "offset").getValue()); } } Index: /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayerTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayerTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayerTest.java (revision 15496) @@ -4,7 +4,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import java.awt.Color; import java.util.Arrays; @@ -17,5 +17,8 @@ import org.openstreetmap.josm.data.gpx.GpxLink; import org.openstreetmap.josm.data.gpx.WayPoint; +import org.openstreetmap.josm.data.osm.DataSet; import org.openstreetmap.josm.gui.MainApplication; +import org.openstreetmap.josm.gui.MapFrame; +import org.openstreetmap.josm.gui.layer.OsmDataLayer; import org.openstreetmap.josm.spi.preferences.Config; import org.openstreetmap.josm.testutils.JOSMTestRules; @@ -29,5 +32,5 @@ /** - * Setup tests + * For creating layers */ @Rule @@ -48,10 +51,9 @@ @Test public void testMarkerLayer() { - assertEquals(Color.magenta, MarkerLayer.getGenericColor()); MarkerLayer layer = new MarkerLayer(new GpxData(), "foo", null, null); MainApplication.getLayerManager().addLayer(layer); assertEquals("foo", layer.getName()); - assertEquals(Color.magenta, layer.getColorProperty().get()); + assertNull(layer.getColor()); assertNotNull(layer.getIcon()); assertEquals("0 markers", layer.getToolTipText()); @@ -62,13 +64,13 @@ WayPoint wpt = new WayPoint(LatLon.ZERO); wpt.attr.put(GpxConstants.META_LINKS, Arrays.asList(new GpxLink("https://josm.openstreetmap.de"))); - wpt.addExtension("offset", "1.0"); + wpt.getExtensions().add("josm", "offset", "1.0"); gpx.waypoints.add(wpt); wpt = new WayPoint(LatLon.ZERO); - wpt.addExtension("offset", "NaN"); + wpt.getExtensions().add("josm", "offset", "NaN"); gpx.waypoints.add(wpt); layer = new MarkerLayer(gpx, "bar", null, null); assertEquals("bar", layer.getName()); - assertEquals(Color.magenta, layer.getColorProperty().get()); + assertNull(layer.getColor()); assertNotNull(layer.getIcon()); assertEquals("3 markers", layer.getToolTipText()); @@ -76,3 +78,23 @@ assertTrue(layer.getMenuEntries().length > 10); } + + /** + * Unit test of {@code Main.map.mapView.playHeadMarker}. + */ + @Test + public void testPlayHeadMarker() { + try { + MainApplication.getLayerManager().addLayer(new OsmDataLayer(new DataSet(), "", null)); + MapFrame map = MainApplication.getMap(); + MarkerLayer layer = new MarkerLayer(new GpxData(), null, null, null); + assertNull(map.mapView.playHeadMarker); + MainApplication.getLayerManager().addLayer(layer); + assertNotNull(map.mapView.playHeadMarker); + MainApplication.getLayerManager().removeLayer(layer); + } finally { + if (MainApplication.isDisplayingMapView()) { + MainApplication.getMap().mapView.playHeadMarker = null; + } + } + } } Index: /trunk/test/unit/org/openstreetmap/josm/io/GpxReaderTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/io/GpxReaderTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/io/GpxReaderTest.java (revision 15496) @@ -11,4 +11,6 @@ import java.nio.charset.StandardCharsets; import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; import org.junit.Rule; @@ -70,4 +72,22 @@ /** + * Tests if layer preferences can be read + * @throws Exception if track can't be parsed + */ + @Test + public void testLayerPrefs() throws Exception { + final GpxData data = parseGpxData(TestUtils.getTestDataRoot() + "tracks/tracks-layerprefs.gpx"); + Map e = new HashMap<>(); + e.put("colormode.velocity.tune", "10"); + e.put("lines.arrows.min-distance", "20"); + e.put("colormode", "1"); + e.put("lines", "1"); + e.put("lines.arrows", "true"); + e.put("colormode.dynamic-range", "true"); + e.put("colors", "0"); + assertEquals(data.getLayerPrefs(), e); + } + + /** * Tests invalid data. * @throws Exception always SAXException Index: /trunk/test/unit/org/openstreetmap/josm/io/GpxWriterTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/io/GpxWriterTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/io/GpxWriterTest.java (revision 15496) @@ -4,4 +4,5 @@ import static org.junit.Assert.assertEquals; +import java.awt.Color; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -10,5 +11,7 @@ import java.time.Month; import java.time.ZoneOffset; +import java.util.Arrays; import java.util.Date; +import java.util.HashMap; import java.util.function.Consumer; @@ -18,4 +21,8 @@ import org.openstreetmap.josm.data.gpx.GpxConstants; import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxData.XMLNamespace; +import org.openstreetmap.josm.data.gpx.GpxExtensionCollection; +import org.openstreetmap.josm.data.gpx.GpxTrack; +import org.openstreetmap.josm.data.gpx.GpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.testutils.JOSMTestRules; @@ -88,3 +95,185 @@ " 1.2%n"); } + + /** + * Tests if extensions are written correctly. + * @throws IOException + */ + @Test + public void testExtensions() throws IOException { + GpxData data = new GpxData(); + data.getNamespaces().add(new XMLNamespace("test", "http://example.com/testURI")); //only namespace, no location printed + data.getNamespaces().add(new XMLNamespace("knownprefix", "http://example.com/URI", "http://example.com/location.xsd")); //printed + data.getNamespaces().add(new XMLNamespace("notpresent", "http://example.com/notpresent", "http://example.com/notpresent.xsd")); //NOT printed + + GpxExtensionCollection exts = data.getExtensions(); + data.fromServer = true; //printed + data.getLayerPrefs().put("foo", "bar"); //printed depending on writer config + exts.add("knownprefix", "foo", "bar"); //printed + exts.add("unknownprefix", "foo", "bar"); //NOT printed + + WayPoint wpt = new WayPoint(LatLon.ZERO); + wpt.getExtensions().add("test", "foo", "extension of a waypoint"); //printed + + GpxTrackSegment seg = new GpxTrackSegment(Arrays.asList(wpt)); + seg.getExtensions().add("test", "foo", "extension of a segment"); //printed + + GpxTrack trk = new GpxTrack(Arrays.asList(seg), new HashMap<>()); + + trk.setColor(Color.RED); //printed depending on writer configuration + + data.addTrack(trk); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + GpxWriter writer = new GpxWriter(baos); + + writer.write(data); + assertEquals("\n" + + "\n" + + " \n" + + " \n" + + " \n" + + " bar\n" + + " true\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " #FF0000\n" + + " \n" + + " \n" + + " \n" + + " extension of a segment\n" + + " \n" + + " \n" + + " \n" + + " extension of a waypoint\n" + + " \n" + + " \n" + + " \n" + + " \n" + + "", baos.toString()); + + baos.reset(); + writer.write(data, GpxConstants.ColorFormat.GPXX, true); + assertEquals("\n" + + "\n" + + " \n" + + " \n" + + " \n" + + " bar\n" + + " true\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " Red\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " extension of a segment\n" + + " \n" + + " \n" + + " \n" + + " extension of a waypoint\n" + + " \n" + + " \n" + + " \n" + + " \n" + + "", baos.toString()); + + baos.reset(); + writer.write(data, null, false); + assertEquals("\n" + + "\n" + + " \n" + + " \n" + + " \n" + + " bar\n" + + " true\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " extension of a segment\n" + + " \n" + + " \n" + + " \n" + + " extension of a waypoint\n" + + " \n" + + " \n" + + " \n" + + " \n" + + "", baos.toString()); + + baos.reset(); + writer.write(data, GpxConstants.ColorFormat.GPXX, true); + // checked again to make sure that extensions are shown again after + // being hidden, even if they don't actually have to be converted + // (GPXD -> convertColor() -> GPXX -> hide() -> null -> show() -> GPXX) + assertEquals("\n" + + "\n" + + " \n" + + " \n" + + " \n" + + " bar\n" + + " true\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " Red\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " extension of a segment\n" + + " \n" + + " \n" + + " \n" + + " extension of a waypoint\n" + + " \n" + + " \n" + + " \n" + + " \n" + + "", baos.toString()); + + writer.close(); + } } Index: /trunk/test/unit/org/openstreetmap/josm/io/nmea/NmeaReaderTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/io/nmea/NmeaReaderTest.java (revision 15495) +++ /trunk/test/unit/org/openstreetmap/josm/io/nmea/NmeaReaderTest.java (revision 15496) @@ -25,5 +25,5 @@ import org.openstreetmap.josm.data.gpx.GpxData; import org.openstreetmap.josm.data.gpx.GpxTrack; -import org.openstreetmap.josm.data.gpx.GpxTrackSegment; +import org.openstreetmap.josm.data.gpx.IGpxTrackSegment; import org.openstreetmap.josm.data.gpx.WayPoint; import org.openstreetmap.josm.io.GpxReaderTest; @@ -101,6 +101,6 @@ assertEquals(nTracks, nmeaTrack.getSegments().size()); if (nTracks > 0) { - GpxTrackSegment gpxSeg = gpxTrack.getSegments().iterator().next(); - GpxTrackSegment nmeaSeg = nmeaTrack.getSegments().iterator().next(); + IGpxTrackSegment gpxSeg = gpxTrack.getSegments().iterator().next(); + IGpxTrackSegment nmeaSeg = nmeaTrack.getSegments().iterator().next(); assertEquals(gpxSeg.getBounds(), nmeaSeg.getBounds()); assertEquals(numCoor, gpxSeg.getWayPoints().size());