Changeset 15496 in josm for trunk/src

Timestamp:

2019-11-02T15:11:34+01:00 (4 years ago)

Author:

Don-vip

Message:

fix #16796 - Rework of GPX track colors / layer preferences (patch by Bjoeni)

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/SaveAction.java (modified) (9 diffs)
• actions/SaveActionBase.java (modified) (9 diffs)
• actions/SaveAsAction.java (modified) (1 diff)
• actions/ShowStatusReportAction.java (modified) (1 diff)
• actions/relation/ExportRelationToGpxAction.java (modified) (3 diffs)
• data/Preferences.java (modified) (8 diffs)
• data/gpx/Extensions.java (deleted)
• data/gpx/GpxConstants.java (modified) (4 diffs)
• data/gpx/GpxData.java (modified) (38 diffs)
• data/gpx/GpxExtension.java (added)
• data/gpx/GpxExtensionCollection.java (added)
• data/gpx/GpxImageCorrelation.java (modified) (1 diff)
• data/gpx/GpxTrack.java (modified) (2 diffs)
• data/gpx/GpxTrackSegment.java (modified) (1 diff)
• data/gpx/IGpxTrack.java (added)
• data/gpx/IGpxTrackSegment.java (added)
• data/gpx/IWithAttributes.java (modified) (2 diffs)
• data/gpx/ImmutableGpxTrack.java (modified) (3 diffs)
• data/gpx/ImmutableGpxTrackSegment.java (modified) (2 diffs)
• data/gpx/Line.java (modified) (6 diffs)
• data/gpx/WithAttributes.java (modified) (5 diffs)
• data/osm/DataSet.java (modified) (3 diffs)
• data/preferences/NamedColorProperty.java (modified) (2 diffs)
• gui/dialogs/LayerListDialog.java (modified) (4 diffs)
• gui/dialogs/layer/LayerVisibilityAction.java (modified) (3 diffs)
• gui/io/importexport/FileExporter.java (modified) (1 diff)
• gui/io/importexport/GpxExporter.java (modified) (7 diffs)
• gui/io/importexport/GpxImporter.java (modified) (1 diff)
• gui/layer/CustomizeColor.java (modified) (6 diffs)
• gui/layer/GpxLayer.java (modified) (10 diffs)
• gui/layer/Layer.java (modified) (7 diffs)
• gui/layer/OsmDataLayer.java (modified) (5 diffs)
• gui/layer/geoimage/CorrelateGpxWithImages.java (modified) (2 diffs)
• gui/layer/gpx/ChooseTrackVisibilityAction.java (modified) (14 diffs)
• gui/layer/gpx/ConvertFromGpxLayerAction.java (modified) (7 diffs)
• gui/layer/gpx/CustomizeDrawingAction.java (modified) (4 diffs)
• gui/layer/gpx/DownloadAlongTrackAction.java (modified) (2 diffs)
• gui/layer/gpx/DownloadWmsAlongTrackAction.java (modified) (2 diffs)
• gui/layer/gpx/GpxDrawHelper.java (modified) (25 diffs)
• gui/layer/gpx/ImportAudioAction.java (modified) (5 diffs)
• gui/layer/markerlayer/AudioMarker.java (modified) (2 diffs)
• gui/layer/markerlayer/DefaultMarkerProducers.java (modified) (2 diffs)
• gui/layer/markerlayer/Marker.java (modified) (8 diffs)
• gui/layer/markerlayer/MarkerLayer.java (modified) (9 diffs)
• gui/layer/markerlayer/PlayHeadMarker.java (modified) (2 diffs)
• gui/preferences/display/ColorPreference.java (modified) (4 diffs)
• gui/preferences/display/GPXSettingsPanel.java (modified) (17 diffs)
• io/GpxReader.java (modified) (19 diffs)
• io/GpxWriter.java (modified) (16 diffs)
• io/nmea/NmeaReader.java (modified) (2 diffs)
• io/rtklib/RtkLibPosReader.java (modified) (2 diffs)
• io/session/GenericSessionExporter.java (modified) (1 diff)

trunk/src/org/openstreetmap/josm/actions/SaveAction.java

@@ -5 +5 @@
 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 +24 @@
 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 +43 @@
     };
 
+    private final GpxDataChangeListener updateOnRequireSaveChangeGpx = evt -> updateEnabledState();
+
     /**
      * Construct the action with "Save" as label.
@@ -38 +50 @@
     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 +68 @@
             @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 +80 @@
             @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 +95 @@
     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 +108 @@
         }
 
-        // 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 +122 @@
                     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);
             }
         }

trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java

@@ -20 +20 @@
 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 +35 @@
 public abstract class SaveActionBase extends DiskAccessAction {
 
+    private boolean quiet;
+
     /**
      * Constructs a new {@code SaveActionBase}.
@@ -47 +48 @@
     }
 
+    /**
+     * 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 +74 @@
      */
     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 +97 @@
      */
     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 +120 @@
      * @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 +127 @@
         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 +139 @@
             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 +161 @@
             }
             layer.setAssociatedFile(file);
-            if (layer instanceof OsmDataLayer) {
-                ((OsmDataLayer) layer).onPostSaveToFile();
+            if (layer instanceof AbstractModifiableLayer) {
+                ((AbstractModifiableLayer) layer).onPostSaveToFile();
             }
         } catch (IOException | InvalidPathException e) {

trunk/src/org/openstreetmap/josm/actions/SaveAsAction.java

@@ -25 +25 @@
         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"));
     }

trunk/src/org/openstreetmap/josm/actions/ShowStatusReportAction.java

@@ -294 +294 @@
 
         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)

trunk/src/org/openstreetmap/josm/actions/relation/ExportRelationToGpxAction.java

@@ -26 +26 @@
 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 +155 @@
                 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 +180 @@
                 }
             }
-            gpxData.addTrack(new ImmutableGpxTrack(trk, trkAttr));
+            gpxData.addTrack(new GpxTrack(trk, trkAttr));
 
             String lprefix = relations.iterator().next().getName();

trunk/src/org/openstreetmap/josm/data/Preferences.java

@@ -22 +22 @@
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -30 +31 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -82 +84 @@
 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 +90 @@
     };
 
+    /** 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<String> 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<String, String> UPDATE_PREF_KEYS = getUpdatePrefKeys();
+
+    private static Map<String, String> getUpdatePrefKeys() {
+        HashMap<String, String> 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 +490 @@
         settingsMap.clear();
         settingsMap.putAll(reader.getSettings());
-        removeObsolete(reader.getVersion());
+        removeAndUpdateObsolete(reader.getVersion());
     }
 
@@ -521 +595 @@
             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 +631 @@
                 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 +830 @@
 
     /**
-     * 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<String, String> 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;
         }
     }

trunk/src/org/openstreetmap/josm/data/gpx/GpxConstants.java

@@ -2 +2 @@
 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 +99 @@
      */
     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 +179 @@
     List<String> 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 +185 @@
      */
     List<String> 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<String, Color> GARMIN_COLORS = getGarminColors();
+
+    /**
+     * Helper method for {@link #GARMIN_COLORS}
+     * @return Map with all supported Garmin colors
+     */
+    static Map<String, Color> getGarminColors() {
+        TreeMap<String, Color> 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<String, String> EXTENSION_ABBREVIATIONS = getExtensionAbbreviations();
+
+    /**
+     * Helper method for {@link #EXTENSION_ABBREVIATIONS}
+     * @return Map with all supported extension abbreviations
+     */
+    static Map<String, String> getExtensionAbbreviations() {
+        TreeMap<String, String> 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;
+    }
 
     /**

trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java

@@ -16 +16 @@
 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 +26 @@
 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 +43 @@
 
     /**
+     * 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 <code>null</code>.
      */
@@ -66 +82 @@
      */
     private final ArrayList<WayPoint> privateWaypoints = new ArrayList<>();
-    private final GpxTrackChangeListener proxy = e -> fireInvalidate();
+    /**
+     * All namespaces read from the original file
+     */
+    private final List<XMLNamespace> 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<String, String> layerPrefs = new HashMap<>();
+
+    private final GpxTrackChangeListener proxy = e -> invalidate();
+    private boolean modified, updating, initializing;
+    private boolean suppressedInvalidate;
 
     /**
@@ -72 +100 @@
      * @see #getTracks()
      */
-    public final Collection<GpxTrack> tracks = new ListeningCollection<GpxTrack>(privateTracks, this::fireInvalidate) {
+    public final Collection<GpxTrack> tracks = new ListeningCollection<GpxTrack>(privateTracks, this::invalidate) {
 
         @Override
@@ -91 +119 @@
      * @see #getRoutes()
      */
-    public final Collection<GpxRoute> routes = new ListeningCollection<>(privateRoutes, this::fireInvalidate);
+    public final Collection<GpxRoute> routes = new ListeningCollection<>(privateRoutes, this::invalidate);
 
     /**
@@ -97 +125 @@
      * @see #getWaypoints()
      */
-    public final Collection<WayPoint> waypoints = new ListeningCollection<>(privateWaypoints, this::fireInvalidate);
+    public final Collection<WayPoint> waypoints = new ListeningCollection<>(privateWaypoints, this::invalidate);
 
     /**
@@ -108 +136 @@
 
     private final ListenerList<GpxDataChangeListener> listeners = ListenerList.create();
-
-    static class TimestampConfictException extends Exception {}
 
     private List<GpxTrackSegmentSpan> segSpans;
@@ -157 +183 @@
         other.privateWaypoints.forEach(this::addWaypoint);
         dataSources.addAll(other.dataSources);
-        fireInvalidate();
+        invalidate();
     }
 
     private void cutOverlapping(GpxTrack trk, boolean connect) {
-        List<GpxTrackSegment> segsOld = new ArrayList<>(trk.getSegments());
-        List<GpxTrackSegment> segsNew = new ArrayList<>();
-        for (GpxTrackSegment seg : segsOld) {
+        List<IGpxTrackSegment> segsOld = new ArrayList<>(trk.getSegments());
+        List<IGpxTrackSegment> segsNew = new ArrayList<>();
+        for (IGpxTrackSegment seg : segsOld) {
             GpxTrackSegmentSpan s = GpxTrackSegmentSpan.tryGetFromSegment(seg);
             if (s != null && anySegmentOverlapsWith(s)) {
@@ -204 +230 @@
                                     // 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 +248 @@
                             //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 +265 @@
                 }
                 if (!wpsNew.isEmpty()) {
-                    segsNew.add(new ImmutableGpxTrackSegment(wpsNew));
+                    segsNew.add(new GpxTrackSegment(wpsNew));
                 }
             } else {
@@ -248 +274 @@
             privateTracks.add(trk);
         } else if (!segsNew.isEmpty()) {
-            privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes()));
+            privateTracks.add(new GpxTrack(segsNew, trk.getAttributes()));
         }
     }
@@ -254 +280 @@
     private void connectTracks(WayPoint prevWp, GpxTrackSegmentSpan span, Map<String, Object> 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 +336 @@
         }
 
-        static GpxTrackSegmentSpan tryGetFromSegment(GpxTrackSegment seg) {
+        static GpxTrackSegmentSpan tryGetFromSegment(IGpxTrackSegment seg) {
             WayPoint b = getNextWpWithTime(seg, true);
             if (b != null) {
@@ -321 +347 @@
         }
 
-        private static WayPoint getNextWpWithTime(GpxTrackSegment seg, boolean forward) {
+        private static WayPoint getNextWpWithTime(IGpxTrackSegment seg, boolean forward) {
             List<WayPoint> wps = new ArrayList<>(seg.getWayPoints());
             for (int i = forward ? 0 : wps.size() - 1; i >= 0 && i < wps.size(); i += forward ? 1 : -1) {
@@ -341 +367 @@
             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 +400 @@
      * @return {@code Stream<GPXTrack>}
      */
-    private synchronized Stream<GpxTrackSegment> getTrackSegmentsStream() {
+    public synchronized Stream<IGpxTrackSegment> getTrackSegmentsStream() {
         return getTracks().stream().flatMap(trk -> trk.getSegments().stream());
     }
@@ -398 +424 @@
         privateTracks.add(track);
         track.addListener(proxy);
-        fireInvalidate();
+        invalidate();
     }
 
@@ -411 +437 @@
         }
         track.removeListener(proxy);
-        fireInvalidate();
+        invalidate();
     }
 
@@ -421 +447 @@
      */
     public synchronized void combineTracksToSegmentedTrack() {
-        List<GpxTrackSegment> segs = getTrackSegmentsStream()
-                .collect(Collectors.toCollection(ArrayList<GpxTrackSegment>::new));
+        List<IGpxTrackSegment> segs = getTrackSegmentsStream()
+                .collect(Collectors.toCollection(ArrayList<IGpxTrackSegment>::new));
         Map<String, Object> attrs = new HashMap<>(privateTracks.get(0).getAttributes());
 
@@ -432 +458 @@
 
         clearTracks();
-        addTrack(new ImmutableGpxTrack(segs, attrs));
+        addTrack(new GpxTrack(segs, attrs));
     }
 
@@ -468 +494 @@
                     HashMap<String, Object> 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<GpxTrack>::new));
@@ -539 +565 @@
         }
         privateRoutes.add(route);
-        fireInvalidate();
+        invalidate();
     }
 
@@ -551 +577 @@
             throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", route));
         }
-        fireInvalidate();
+        invalidate();
     }
 
@@ -573 +599 @@
         }
         privateWaypoints.add(waypoint);
-        fireInvalidate();
+        invalidate();
     }
 
@@ -585 +611 @@
             throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", waypoint));
         }
-        fireInvalidate();
+        invalidate();
     }
 
@@ -601 +627 @@
      * @see #getTracks()
      * @see GpxTrack#getSegments()
-     * @see GpxTrackSegment#getWayPoints()
+     * @see IGpxTrackSegment#getWayPoints()
      * @since 12156
      */
@@ -768 +794 @@
         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 +909 @@
         private Iterator<GpxTrack> itTracks;
         private int idxTracks;
-        private Iterator<GpxTrackSegment> itTrackSegments;
+        private Iterator<IGpxTrackSegment> itTrackSegments;
         private final Iterator<GpxRoute> itRoutes;
 
@@ -889 +915 @@
         private final boolean[] trackVisibility;
         private Map<String, Object> trackAttributes;
+        private GpxTrack curTrack;
 
         /**
@@ -922 +949 @@
             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 +984 @@
     }
 
+    /**
+     * 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<String, String> getLayerPrefs() {
+        return layerPrefs;
+    }
+
+    /**
+     * All XML namespaces read from the original file
+     * @return Modifiable list
+     * @since 15496
+     */
+    public List<XMLNamespace> 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 +1021 @@
             return true;
         if (obj == null)
+            return false;
+        if (!super.equals(obj))
             return false;
         if (getClass() != obj.getClass())
@@ -981 +1031 @@
                 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 +1052 @@
         } 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 +1092 @@
     }
 
-    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 +1169 @@
         }
     }
+
+    /**
+     * @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;
+        }
+    }
 }

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelation.java

@@ -40 +40 @@
         for (GpxTrack trk : selectedGpx.tracks) {
             List<List<WayPoint>> segs = new ArrayList<>();
-            for (GpxTrackSegment seg : trk.getSegments()) {
+            for (IGpxTrackSegment seg : trk.getSegments()) {
                 List<WayPoint> wps = new ArrayList<>(seg.getWayPoints());
                 if (!wps.isEmpty()) {

trunk/src/org/openstreetmap/josm/data/gpx/GpxTrack.java

@@ -2 +2 @@
 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<GpxTrackSegment> getSegments();
-
-    /**
-     * Returns the track attributes.
-     * @return the track attributes
-     */
-    Map<String, Object> 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<IGpxTrackSegment> segments;
+    private final double length;
+    private final Bounds bounds;
+    private Color colorCache;
+    private final ListenerList<IGpxTrack.GpxTrackChangeListener> listeners = ListenerList.create();
+    private static final HashMap<Color, String> closestGarminColorCache = new HashMap<>();
+    private ColorFormat colorFormat;
+
+    /**
+     * Constructs a new {@code GpxTrack}.
+     * @param trackSegs track segments
+     * @param attributes track attributes
+     */
+    public GpxTrack(Collection<Collection<WayPoint>> trackSegs, Map<String, Object> attributes) {
+        List<IGpxTrackSegment> newSegments = new ArrayList<>();
+        for (Collection<WayPoint> 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<IGpxTrackSegment> trackSegs, Map<String, Object> 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<String, Color> 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<IGpxTrackSegment> 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 +263 @@
     /**
      * 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);
+        }
+    }
+
 }

trunk/src/org/openstreetmap/josm/data/gpx/GpxTrackSegment.java

@@ -2 +2 @@
 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<WayPoint> 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<WayPoint> wayPoints) {
+        this.wayPoints = Collections.unmodifiableList(new ArrayList<>(wayPoints));
+        this.bounds = calculateBounds();
+        this.length = calculateLength();
+    }
 
-    /**
-     * Returns the segment waypoints.
-     * @return the segment waypoints
-     */
-    Collection<WayPoint> 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<WayPoint> 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;
+    }
 }

trunk/src/org/openstreetmap/josm/data/gpx/IWithAttributes.java

@@ -3 +3 @@
 
 import java.util.Collection;
+import java.util.Map;
 
 /**
@@ -51 +52 @@
 
     /**
-     * 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<String, Object> getAttributes();
+
+    /**
+     * Returns the extensions
+     * @return the extensions
+     */
+    GpxExtensionCollection getExtensions();
 
 }

trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrack.java

@@ -2 +2 @@
 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<GpxTrackSegment> segments;
-    private final double length;
-    private final Bounds bounds;
+@Deprecated
+public class ImmutableGpxTrack extends GpxTrack {
 
     /**
@@ -27 +20 @@
      */
     public ImmutableGpxTrack(Collection<Collection<WayPoint>> trackSegs, Map<String, Object> attributes) {
-        List<GpxTrackSegment> newSegments = new ArrayList<>();
-        for (Collection<WayPoint> 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 +32 @@
      * @since 13210
      */
-    public ImmutableGpxTrack(List<GpxTrackSegment> segments, Map<String, Object> 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<String, Object> getAttributes() {
-        return attr;
-    }
-
-    @Override
-    public Bounds getBounds() {
-        return bounds == null ? null : new Bounds(bounds);
-    }
-
-    @Override
-    public double length() {
-        return length;
-    }
-
-    @Override
-    public Collection<GpxTrackSegment> 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<IGpxTrackSegment> segments, Map<String, Object> attributes) {
+        super(segments, attributes);
     }
 }

trunk/src/org/openstreetmap/josm/data/gpx/ImmutableGpxTrackSegment.java

@@ -2 +2 @@
 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<WayPoint> wayPoints;
-    private final Bounds bounds;
-    private final double length;
+@Deprecated
+public class ImmutableGpxTrackSegment extends GpxTrackSegment {
 
     /**
@@ -23 +16 @@
      */
     public ImmutableGpxTrackSegment(Collection<WayPoint> 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<WayPoint> 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);
     }
 }

trunk/src/org/openstreetmap/josm/data/gpx/Line.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.gpx;
 
+import java.awt.Color;
 import java.util.Collection;
 import java.util.Iterator;
@@ -14 +15 @@
     private final Collection<WayPoint> waypoints;
     private final boolean unordered;
+    private final Color color;
 
     /**
@@ -19 +21 @@
      * @param waypoints collection of waypoints
      * @param attributes track/route attributes
+     * @param color color of the track
+     * @since 15496
      */
-    public Line(Collection<WayPoint> waypoints, Map<String, Object> attributes) {
+    public Line(Collection<WayPoint> waypoints, Map<String, Object> 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 +34 @@
      * @param trackSegment track segment
      * @param trackAttributes track attributes
+     * @param color color of the track
+     * @since 15496
      */
-    public Line(GpxTrackSegment trackSegment, Map<String, Object> trackAttributes) {
-        this(trackSegment.getWayPoints(), trackAttributes);
+    public Line(IGpxTrackSegment trackSegment, Map<String, Object> trackAttributes, Color color) {
+        this(trackSegment.getWayPoints(), trackAttributes, color);
     }
 
@@ -39 +46 @@
      */
     public Line(GpxRoute route) {
-        this(route.routePoints, route.attr);
+        this(route.routePoints, route.attr, null);
     }
 
@@ -48 +55 @@
     public boolean isUnordered() {
         return unordered;
+    }
+
+    /**
+     * Returns the track/route color
+     * @return the color
+     * @since 15496
+     */
+    public Color getColor() {
+        return color;
     }
 

trunk/src/org/openstreetmap/josm/data/gpx/WithAttributes.java

@@ -5 +5 @@
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 /**
@@ -20 +21 @@
      */
     public Map<String, Object> attr = new HashMap<>(0);
+
+    /**
+     * The "exts" collection contains all extensions.
+     */
+    private final GpxExtensionCollection exts = new GpxExtensionCollection(this);
 
     /**
@@ -65 +71 @@
     /**
      * Put a key / value pair as a new attribute.
-     *
      * Overrides key / value pair with the same key (if present).
      *
@@ -76 +81 @@
     }
 
-    /**
-     * 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<String, Object> 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 +110 @@
         } 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;
     }

trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

@@ -33 +33 @@
 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 +172 @@
 
     /**
+     * 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<XMLNamespace> GPXNamespaces;
+
+    /**
      * Constructs a new {@code DataSet}.
      */
@@ -1195 +1202 @@
 
     /**
+     * Gets the GPX (XML) namespaces if this DataSet was created from a GPX file
+     * @return the GPXNamespaces or <code>null</code>
+     */
+    public List<XMLNamespace> getGPXNamespaces() {
+        return GPXNamespaces;
+    }
+
+    /**
+     * Sets the GPX (XML) namespaces
+     * @param GPXNamespaces the GPXNamespaces to set
+     */
+    public void setGPXNamespaces(List<XMLNamespace> GPXNamespaces) {
+        this.GPXNamespaces = GPXNamespaces;
+    }
+
+    /**
      * @return true if this Dataset contains no primitives
      * @since 14835

trunk/src/org/openstreetmap/josm/data/preferences/NamedColorProperty.java

@@ -23 +23 @@
     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 +31 @@
      * 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

trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

@@ -4 +4 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 
-import java.awt.Color;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -18 +17 @@
 import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.CopyOnWriteArrayList;
 
@@ -43 +42 @@
 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 +610 @@
             }
             if (Config.getPref().getBoolean("dialog.layer.colorname", true)) {
-                AbstractProperty<Color> 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());

trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerVisibilityAction.java

@@ -594 +594 @@
                     for (Layer l : layers) {
                         if (l instanceof GpxLayer) {
-                            l.getColorProperty().put(color);
+                            l.setColor(color);
                         }
                     }
@@ -603 +603 @@
             panels.put(color, colorPanel);
 
-            List<Color> colors = layerSupplier.get().stream().map(l -> l.getColorProperty().get()).distinct().collect(Collectors.toList());
+            List<Color> colors = layerSupplier.get().stream().map(l -> l.getColor()).distinct().collect(Collectors.toList());
             if (colors.size() == 1) {
                 highlightColor(colors.get(0));
@@ -612 +612 @@
         public void updateLayers(List<Layer> layers, boolean allVisible, boolean allHidden) {
             List<Color> colors = layers.stream().filter(l -> l instanceof GpxLayer)
-                    .map(l -> ((GpxLayer) l).getColorProperty().get())
+                    .map(l -> ((GpxLayer) l).getColor())
                     .distinct()
                     .collect(Collectors.toList());

trunk/src/org/openstreetmap/josm/gui/io/importexport/FileExporter.java

@@ -56 +56 @@
 
     /**
+     * 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

trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxExporter.java

@@ -26 +26 @@
 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 +79 @@
     @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 +100 @@
         }
 
+        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 +168 @@
         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 +190 @@
             .setContent(p);
 
+        colors.addActionListener(l -> {
+            garmin.setEnabled(colors.isSelected());
+        });
+
+        garmin.addActionListener(l -> {
+            if (garmin.isSelected() &&
+                    !ConditionalOptionPaneUtil.showConfirmationDialog(
+                            "gpx_color_garmin",
+                            ed,
+                            new JLabel(tr("<html>Garmin track extensions only support 16 colors.<br>If you continue, the closest supported track color will be used.</html>")),
+                            tr("Information"),
+                            JOptionPane.OK_CANCEL_OPTION,
+                            JOptionPane.INFORMATION_MESSAGE,
+                            JOptionPane.OK_OPTION)) {
+                garmin.setSelected(false);
+            }
+        });
+
         if (ed.showDialog().getValue() != 1) {
             setCanceled(true);
@@ -168 +221 @@
             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 +260 @@
         }
 
-        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);
     }
 

trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxImporter.java

@@ -150 +150 @@
             if (markerLayer.data.isEmpty()) {
                 markerLayer = null;
+            } else {
+                gpxLayer.setLinkedMarkerLayer(markerLayer);
             }
         }

trunk/src/org/openstreetmap/josm/gui/layer/CustomizeColor.java

@@ -19 +19 @@
 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 +32 @@
  */
 public class CustomizeColor extends AbstractAction implements LayerAction, MultiLayerAction {
-    private final transient List<AbstractProperty<Color>> colors;
+    private final transient List<Layer> colorLayers;
 
     /**
@@ -43 +41 @@
         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 +55 @@
     @Override
     public boolean supportLayers(List<Layer> layers) {
-        return layers.stream().allMatch(l -> l.getColorProperty() != null);
+        return layers.stream().allMatch(Layer::hasColor);
     }
 
@@ -73 +70 @@
     @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 +85 @@
         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;
         }

trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

@@ -5 +5 @@
 import static org.openstreetmap.josm.tools.I18n.trn;
 
+import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics2D;
@@ -14 +15 @@
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import javax.swing.AbstractAction;
@@ -32 +34 @@
 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 +48 @@
 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 +59 @@
  * 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 +78 @@
      */
     private final GpxDataChangeListener dataChangeListener = e -> this.invalidate();
+    /**
+     * The MarkerLayer imported from the same file.
+     */
+    private MarkerLayer linkedMarkerLayer;
 
     /**
@@ -109 +118 @@
 
     @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 +302 @@
             .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("<br>")
-            .append(tr("Length: {0}", SystemOfMeasurement.getSystemOfMeasurement().getDistText(data.length())))
-            .append("<br></html>");
+            .append(tr("Length: {0}", SystemOfMeasurement.getSystemOfMeasurement().getDistText(data.length())));
+
+        if (Logging.isDebugEnabled() && !data.getLayerPrefs().isEmpty()) {
+            info.append("<br><br>")
+                .append(String.join("<br>", data.getLayerPrefs().entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.toList())));
+        }
+
+        info.append("<br></html>");
+
         return info.toString();
     }
@@ -340 +372 @@
     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 +529 @@
 
     @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

trunk/src/org/openstreetmap/josm/gui/layer/Layer.java

@@ -26 +26 @@
 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 +162 @@
     private File associatedFile;
 
-    private final ValueChangeListener<Object> invalidateListener = change -> invalidate();
     private boolean isDestroyed;
 
@@ -199 +195 @@
 
     /**
-     * Gets the color property to use for this layer.
-     * @return The color property.
-     * @since 10824
-     */
-    public AbstractProperty<Color> 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 <code>null</code> 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<Color> colorProperty = getColorProperty();
-        if (colorProperty != null) {
-            colorProperty.addListener(invalidateListener);
-        }
-    }
-
-    private void removeColorPropertyListener() {
-        AbstractProperty<Color> 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, <code>null</code> for default
+     * @since 15496
+     */
+    public void setColor(Color color) {
     }
 
@@ -303 +287 @@
         isDestroyed = true;
         // Override in subclasses if needed
-        removeColorPropertyListener();
     }
 
@@ -340 +323 @@
      */
     public void setName(String name) {
-        if (this.name != null) {
-            removeColorPropertyListener();
-        }
         String oldValue = this.name;
         this.name = Optional.ofNullable(name).orElse("");
@@ -348 +328 @@
             propertyChangeSupport.firePropertyChange(NAME_PROP, oldValue, this.name);
         }
-
-        // re-add listener
-        addColorPropertyListener();
         invalidate();
     }
@@ -540 +517 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            SaveAction.getInstance().doSave(layer);
+            SaveAction.getInstance().doSave(layer, true);
         }
     }

trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

@@ -32 +32 @@
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
@@ -61 +62 @@
 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 +762 @@
     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<Node> doneNodes = new HashSet<>();
@@ -778 +785 @@
                 return;
             }
-            Collection<Collection<WayPoint>> trk = new ArrayList<>();
+            List<IGpxTrackSegment> trk = new ArrayList<>();
             Map<String, Object> trkAttr = new HashMap<>();
 
-            String name = gpxVal(w, "name");
-            if (name != null) {
-                trkAttr.put("name", name);
-            }
-
-            List<WayPoint> trkseg = null;
+            GpxExtensionCollection trkExts = new GpxExtensionCollection();
+            GpxExtensionCollection segExts = new GpxExtensionCollection();
+            for (Entry<String, String> 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<WayPoint> 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 +827 @@
                 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);
         });
     }

trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java

@@ -71 +71 @@
 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 +1269 @@
         // 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()) {

trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java

@@ -5 +5 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 
+import java.awt.Color;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -13 +14 @@
 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 +32 @@
 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 +44 @@
 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 +65 @@
      */
     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 +126 @@
             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 +132 @@
     }
 
+    private void showColorDialog(List<GpxTrack> 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 +178 @@
                     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 +218 @@
             @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 +275 @@
         t.addMouseListener(urlOpener);
         t.setFillsViewportHeight(true);
+        t.putClientProperty("terminateEditOnFocusLost", true);
         return t;
     }
@@ -250 +345 @@
         msg.add(new JLabel(tr("<html>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.</html>")),
+                "The map is updated live in the background. Open the URLs by double clicking them, " +
+                "edit name and description by double clicking the cell.</html>")),
                 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 +360 @@
         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<GpxTrack> 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 +390 @@
         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 +405 @@
         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());
     }
 }

trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertFromGpxLayerAction.java

@@ -8 +8 @@
 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 +21 @@
 
 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 +57 @@
     public DataSet convert() {
         final DataSet ds = new DataSet();
+        ds.setGPXNamespaces(layer.data.getNamespaces());
 
         List<String> keys = new ArrayList<>(); // note that items in this list don't have the GPX_PREFIX
@@ -60 +64 @@
         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<Node> nodes = new ArrayList<>();
                 for (WayPoint p : segment.getWayPoints()) {
                     Node n = new Node(p.getCoor());
-                    for (Entry<String, Object> 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 +78 @@
                 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 +119 @@
     }
 
+    private static void addAttributes(Map<String, Object> attr, OsmPrimitive p, List<String> keys, boolean check, boolean none) {
+        for (Entry<String, Object> 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<String> 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 +172 @@
      */
     public DataSet filterDataSet(DataSet ds, List<String> listPos) {
-        Collection<Node> 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);
                 }
             }

trunk/src/org/openstreetmap/josm/gui/layer/gpx/CustomizeDrawingAction.java

@@ -10 +10 @@
 import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import javax.swing.AbstractAction;
@@ -60 +61 @@
     @Override
     public boolean supportLayers(List<Layer> layers) {
-        for (Layer layer : layers) {
-            if (!(layer instanceof GpxLayer)) {
-                return false;
-            }
-        }
-        return true;
+        return layers.stream().allMatch(l -> l instanceof GpxLayer);
     }
 
@@ -80 +76 @@
     @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 +89 @@
             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);
     }
 

trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongTrackAction.java

@@ -9 +9 @@
 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 +61 @@
         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()) {

trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadWmsAlongTrackAction.java

@@ -17 +17 @@
 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 +93 @@
         List<LatLon> 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());

trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java

@@ -28 +28 @@
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Objects;
 import java.util.Random;
 
@@ -33 +34 @@
 
 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 +52 @@
 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 +67 @@
 
     /**
-     * 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 +80 @@
     private boolean alphaLines;
     // draw direction arrows on the lines
-    private boolean direction;
+    private boolean arrows;
     /** width of line for paint **/
     private int lineWidth;
@@ -91 +92 @@
     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 +108 @@
     private boolean computeCacheColorDynamic;
     private ColorMode computeCacheColored;
-    private int computeCacheColorTracksTune;
+    private int computeCacheVelocityTune;
     private int computeCacheHeatMapDrawColorTableIdx;
     private boolean computeCacheHeatMapDrawPointMode;
@@ -113 +114 @@
     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 +150 @@
     /** heat map parameters **/
 
-    // enabled or not (override by settings)
-    private boolean heatMapEnabled;
     // draw small extra line
     private boolean heatMapDrawExtraLine;
@@ -269 +271 @@
     }
 
-    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 +286 @@
     }
 
-    /** 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 +352 @@
         List<WayPoint> visibleSegments = listVisibleSegments(clipBounds);
         if (!visibleSegments.isEmpty()) {
-            readPreferences(layer.getName());
+            readPreferences();
             drawAll(graphics.getDefaultGraphics(), graphics.getMapView(), visibleSegments, clipBounds);
             if (graphics.getMapView().getLayerManager().getActiveLayer() == layer) {
@@ -431 +414 @@
      * @since 14748 : new parameter clipBounds
      */
-
     public void drawAll(Graphics2D g, MapView mv, List<WayPoint> visibleSegments, Bounds clipBounds) {
 
@@ -463 +445 @@
 
         // global enabled or select via color
-        boolean useHeatMap = heatMapEnabled || ColorMode.HEATMAP == colored;
+        boolean useHeatMap = ColorMode.HEATMAP == colored;
 
         // default global alpha level
@@ -571 +553 @@
             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 +577 @@
             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 +625 @@
                 } else { // make sure we reset outdated data
                     trkPnt.drawLine = false;
-                    color = neutralColor;
+                    color = segment.getColor();
                 }
                 if (color != null) {
@@ -701 +683 @@
          ********** STEP 3b - DRAW NICE ARROWS **************************
          ****************************************************************/
-        if (lines && direction && !alternateDirection) {
+        if (lines && arrows && !arrowsFast) {
             Point old = null;
             Point oldA = null; // last arrow painted
@@ -713 +695 @@
                     // 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 +713 @@
          ********** STEP 3c - DRAW FAST ARROWS **************************
          ****************************************************************/
-        if (lines && direction && alternateDirection) {
+        if (lines && arrows && arrowsFast) {
             Point old = null;
             Point oldA = null; // last arrow painted
@@ -743 +725 @@
                     // 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 +777 @@
                     // 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 +804 @@
                 }
                 if (!trkPnt.drawLine) {
+                    g.setColor(trkPnt.customColoring);
                     Point screen = mv.getPoint(trkPnt);
                     g.drawRect(screen.x, screen.y, 0, 0);
@@ -1481 +1470 @@
         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 +1483 @@
             computeCacheColorUsed = neutralColor;
             computeCacheColored = colored;
-            computeCacheColorTracksTune = colorTracksTune;
+            computeCacheVelocityTune = velocityTune;
             computeCacheColorDynamic = colorModeDynamic;
             computeCacheHeatMapDrawColorTableIdx = heatMapDrawColorTableIdx;

trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java

@@ -22 +22 @@
 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 +148 @@
         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 +207 @@
                 && !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 +228 @@
 
             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 +264 @@
             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());

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/AudioMarker.java

@@ -94 +94 @@
 
     @Override
-    protected TemplateEntryProperty getTextTemplate() {
-        return TemplateEntryProperty.forAudioMarker(parentLayer.getName());
+    protected String getTextTemplateKey() {
+        return "markers.audio.pattern";
     }
 
@@ -104 +104 @@
         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;
     }

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/DefaultMarkerProducers.java

@@ -10 +10 @@
 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 +46 @@
         } 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);

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java

@@ -19 +19 @@
 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 +27 @@
 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 +74 @@
 public class Marker implements TemplateEngineDataProvider, ILatLon {
 
-    public static final class TemplateEntryProperty extends CachedProperty<TemplateEntry> {
-        // 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<String, TemplateEntryProperty> 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 +144 @@
 
     private String cachedText;
-    private int textVersion = -1;
+    private static Map<GpxLayer, String> cachedTemplates = new HashMap<>();
+    private String cachedDefaultTemplate;
+
     private CachedLatLon coor;
 
@@ -245 +174 @@
         this.dataProvider = dataProvider;
         this.text = text;
+
+        Preferences.main().addKeyPreferenceChangeListener("draw.rawgps." + getTextTemplateKey(), l -> updateText());
     }
 
@@ -258 +189 @@
         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 +304 @@
     }
 
-    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 +331 @@
      */
     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<>();
     }
 

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

@@ -21 +21 @@
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 
 import javax.swing.AbstractAction;
@@ -31 +32 @@
 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 +50 @@
 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 +78 @@
     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 +100 @@
         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 +140 @@
             // 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 +190 @@
 
     @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 +456 @@
      */
     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 +536 @@
         @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();
         }

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java

@@ -19 +19 @@
 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 +328 @@
 
         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()) {

trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java

@@ -101 +101 @@
         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 +239 @@
             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 +366 @@
     }
 
+    @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 +381 @@
         ConflictColors.getColors();
         Severity.getColors();
-        MarkerLayer.getGenericColor();
-        GpxDrawHelper.getGenericColor();
+        MarkerLayer.DEFAULT_COLOR_PROPERTY.get();
+        GpxDrawHelper.DEFAULT_COLOR_PROPERTY.get();
         OsmDataLayer.getOutsideColor();
         MapScaler.getColor();

trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java

@@ -5 +5 @@
 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 +27 @@
 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 +72 @@
     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<String> colorTypeVelocityTune = new JosmComboBox<>(new String[] {tr("Car"), tr("Bicycle"), tr("Foot")});
@@ -94 +98 @@
     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<GpxLayer> 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<String, Object> DEFAULT_PREFS = getDefaultPrefs();
+
+    private static Map<String, Object> getDefaultPrefs() {
+        HashMap<String, Object> 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<GpxLayer> 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 +160 @@
     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 <code>null</code>, 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 <code>null</code>, 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 <code>null</code> 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 <code>null</code> 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 <code>null</code>
+     * @param layers List of <code>GpxLayer</code> to put the drawingOptions
+     * @param key the drawing key to be written, without "draw.rawgps."
+     * @param value (can be <code>null</code> to remove option)
+     */
+    public static void putLayerPref(List<GpxLayer> 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 <code>GpxLayer</code> to put the drawingOptions
+     * @param key the drawing key to be written, without "draw.rawgps."
+     * @param value the value or <code>null</code> 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 <code>GpxData</code> to put the drawingOptions. Must not be <code>null</code>
+     * @param key the drawing key to be written, without "draw.rawgps."
+     * @param value the value or <code>null</code> 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 +299 @@
         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 +319 @@
         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 +416 @@
         // colorTracks
         ButtonGroup colorGroup = new ButtonGroup();
-        if (layerName != null) {
+        if (!global) {
             colorGroup.add(colorTypeGlobal);
         }
@@ -254 +427 @@
         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 +446 @@
 
         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 +505 @@
                 // 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 +522 @@
         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 +532 @@
             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 +547 @@
             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 +562 @@
     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 +595 @@
             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 +606 @@
             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<String> cb, JosmTextField tf, TemplateEntryProperty property) {
-        String labelPattern = property.getAsString();
+    private static void updateWaypointLabelCombobox(JosmComboBox<String> cb, JosmTextField tf, String labelPattern) {
         boolean found = false;
         for (int i = 0; i < LABEL_PATTERN_TEMPLATE.length; i++) {

trunk/src/org/openstreetmap/josm/io/GpxReader.java

@@ -19 +19 @@
 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 +71 @@
 
         private GpxData data;
-        private Collection<Collection<WayPoint>> currentTrack;
+        private Collection<IGpxTrackSegment> currentTrack;
         private Map<String, Object> currentTrackAttr;
         private Collection<WayPoint> currentTrackSeg;
@@ -77 +80 @@
 
         private GpxLink currentLink;
-        private Extensions currentExtensions;
+        private GpxExtensionCollection currentExtensionCollection;
+        private GpxExtensionCollection currentTrackExtensionCollection;
         private Stack<State> states;
         private final Stack<String> elements = new Stack<>();
@@ -89 +93 @@
             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 +145 @@
                     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 +182 @@
                     states.push(currentState);
                     currentState = State.EXT;
-                    currentExtensions = new Extensions();
                     break;
                 case "gpx":
@@ -179 +200 @@
                     states.push(currentState);
                     currentState = State.EXT;
-                    currentExtensions = new Extensions();
                     break;
                 case "copyright":
@@ -229 +249 @@
                     states.push(currentState);
                     currentState = State.EXT;
-                    currentExtensions = new Extensions();
                     break;
                 default: // Do nothing
@@ -235 +254 @@
                 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 +276 @@
                     states.push(currentState);
                     currentState = State.EXT;
-                    currentExtensions = new Extensions();
                     break;
                 default: // Do nothing
@@ -271 +295 @@
                     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 +380 @@
                         (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 +389 @@
                     break;
                 default:
-                    //TODO: parse extensions
                 }
                 break;
@@ -465 +493 @@
                     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 +503 @@
                 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 +516 @@
                     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 +537 @@
                 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 +559 @@
                 }
             }
+            accumulator.setLength(0);
         }
 
@@ -526 +566 @@
             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;
         }

trunk/src/org/openstreetmap/josm/io/GpxWriter.java

@@ -9 +9 @@
 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 +21 @@
 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 +59 @@
     private GpxData data;
     private String indent = "";
+    private List<String> validprefixes;
 
     private static final int WAY_POINT = 0;
@@ -65 +70 @@
      */
     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<IWithAttributes> 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<XMLNamespace> 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("<?xml version='1.0' encoding='UTF-8'?>");
         out.println("<gpx version=\"1.1\" creator=\"JOSM GPX export\" xmlns=\"http://www.topografix.com/GPX/1/1\"");
-        out.println((hasExtensions ? String.format("    xmlns:josm=\"%s\"%n", JOSM_EXTENSIONS_NAMESPACE_URI) : "") +
-                    "    xmlns:xsi=\""+XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI+"\"");
-        out.println("    xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">");
+
+        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 +158 @@
                         gpxLink(link);
                     }
-                }
-            } else if (META_EXTENSIONS.equals(key)) {
-                Extensions extensions = (Extensions) obj.get(key);
-                if (extensions != null) {
-                    gpxExtensions(extensions);
                 }
             } else {
@@ -148 +196 @@
                 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 +207 @@
         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 +236 @@
         }
 
-        if (data.fromServer) {
-            openln("extensions");
-            simpleTag("josm:from-server", "true");
-            closeln("extensions");
-        }
-
+        gpxExtensions(data.getExtensions());
         closeln("metadata");
     }
@@ -207 +250 @@
             openln("rte");
             writeAttr(rte, RTE_TRK_KEYS);
+            gpxExtensions(rte.getExtensions());
             for (WayPoint pnt : rte.routePoints) {
                 wayPoint(pnt, ROUTE_POINT);
@@ -218 +262 @@
             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 +280 @@
     }
 
+    private void openln(String tag, String attributes) {
+        open(tag, attributes);
+        out.println();
+    }
+
     private void open(String tag) {
         out.print(indent + '<' + tag + '>');
@@ -239 +290 @@
     }
 
-    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 +324 @@
     }
 
+    private void simpleTag(String tag, String content, String attributes) {
+        if (content != null && !content.isEmpty()) {
+            open(tag, attributes);
+            out.print(encode(content));
+            out.println("</" + tag + '>');
+            indent = indent.substring(2);
+        }
+    }
+
     /**
      * output link
@@ -279 +339 @@
     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 +369 @@
             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 +380 @@
     }
 
-    private void gpxExtensions(Extensions extensions) {
-        if (extensions != null && !extensions.isEmpty()) {
+    private void gpxExtensions(GpxExtensionCollection allExtensions) {
+        if (allExtensions.isVisible()) {
             openln("extensions");
-            for (Entry<String, String> e : extensions.entrySet()) {
-                simpleTag("josm:" + e.getKey(), e.getValue());
-            }
+            writeExtension(allExtensions);
             closeln("extensions");
         }
     }
+
+    private void writeExtension(List<GpxExtension> 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);
+                }
+            }
+        }
+    }
 }

trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java

@@ -21 +21 @@
 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 +265 @@
             }
             currentTrack.add(ps.waypoints);
-            data.tracks.add(new ImmutableGpxTrack(currentTrack, Collections.<String, Object>emptyMap()));
+            data.tracks.add(new GpxTrack(currentTrack, Collections.<String, Object>emptyMap()));
 
         } catch (IllegalDataException e) {

trunk/src/org/openstreetmap/josm/io/rtklib/RtkLibPosReader.java

@@ -19 +19 @@
 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 +115 @@
         }
         currentTrack.add(waypoints);
-        data.tracks.add(new ImmutableGpxTrack(currentTrack, Collections.<String, Object>emptyMap()));
+        data.tracks.add(new GpxTrack(currentTrack, Collections.<String, Object>emptyMap()));
         return true;
     }

trunk/src/org/openstreetmap/josm/io/session/GenericSessionExporter.java

@@ -82 +82 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            SaveAction.getInstance().doSave(layer);
+            SaveAction.getInstance().doSave(layer, true);
             updateEnabledState();
         }