Changeset 12156 in josm for trunk/src/org/openstreetmap

Timestamp:

2017-05-15T14:14:40+02:00 (8 years ago)

Author:

michael2402

Message:

See #14120: Don't make gpx tracks depend on the isChanged method, use a listener based approach instead.

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/gpx/GpxData.java (modified) (15 diffs)
• data/gpx/GpxTrack.java (modified) (1 diff)
• gui/layer/GpxLayer.java (modified) (13 diffs)
• gui/layer/OsmDataLayer.java (modified) (1 diff)
• gui/layer/gpx/ChooseTrackVisibilityAction.java (modified) (2 diffs)
• gui/layer/gpx/ConvertToDataLayerAction.java (modified) (1 diff)
• gui/layer/gpx/MarkersFromNamedPointsAction.java (modified) (2 diffs)
• gui/layer/markerlayer/PlayHeadMarker.java (modified) (1 diff)
• io/GpxReader.java (modified) (2 diffs)
• io/GpxWriter.java (modified) (3 diffs)

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

@@ -3 +3 @@
 
 import java.io.File;
+import java.text.MessageFormat;
+import java.util.AbstractCollection;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -9 +12 @@
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.Main;
@@ -19 +22 @@
 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.tools.ListenerList;
 
 /**
@@ -35 +40 @@
     public String creator;
 
-    /** Tracks */
-    public final Collection<GpxTrack> tracks = new LinkedList<>();
-    /** Routes */
-    public final Collection<GpxRoute> routes = new LinkedList<>();
-    /** Waypoints */
-    public final Collection<WayPoint> waypoints = new LinkedList<>();
+    private ArrayList<GpxTrack> privateTracks = new ArrayList<>();
+    private ArrayList<GpxRoute> privateRoutes = new ArrayList<>();
+    private ArrayList<WayPoint> privateWaypoints = new ArrayList<>();
+    private final GpxTrackChangeListener proxy = e -> fireInvalidate();
+
+    /**
+     * Tracks. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getTracks()
+     */
+    public final Collection<GpxTrack> tracks = new ListeningCollection<GpxTrack>(privateTracks, this::fireInvalidate) {
+
+        @Override
+        protected void removed(GpxTrack cursor) {
+            cursor.removeListener(proxy);
+            super.removed(cursor);
+        }
+
+        @Override
+        protected void added(GpxTrack cursor) {
+            super.added(cursor);
+            cursor.addListener(proxy);
+        }
+    };
+
+    /**
+     * Routes. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getRoutes()
+     */
+    public final Collection<GpxRoute> routes = new ListeningCollection<>(privateRoutes, this::fireInvalidate);
+
+    /**
+     * Waypoints. Access is discouraged, use {@link #getTracks()} to read.
+     * @see #getWaypoints()
+     */
+    public final Collection<WayPoint> waypoints = new ListeningCollection<>(privateWaypoints, this::fireInvalidate);
 
     /**
@@ -49 +83 @@
      */
     public final Set<DataSource> dataSources = new HashSet<>();
+
+    private final ListenerList<GpxDataChangeListener> listeners = ListenerList.create();
 
     /**
@@ -72 +108 @@
             }
         }
-        tracks.addAll(other.tracks);
-        routes.addAll(other.routes);
-        waypoints.addAll(other.waypoints);
+        privateTracks.addAll(other.getTracks());
+        privateRoutes.addAll(other.getRoutes());
+        privateWaypoints.addAll(other.getWaypoints());
         dataSources.addAll(other.dataSources);
+        fireInvalidate();
+    }
+
+    /**
+     * Get all tracks contained in this data set.
+     * @return The tracks.
+     */
+    public Collection<GpxTrack> getTracks() {
+        return Collections.unmodifiableCollection(privateTracks);
+    }
+
+    /**
+     * Add a new track
+     * @param track The new track
+     * @since 12156
+     */
+    public void addTrack(GpxTrack track) {
+        if (privateTracks.contains(track)) {
+            throw new IllegalArgumentException(MessageFormat.format("The track was already added to this data: {0}", track));
+        }
+        privateTracks.add(track);
+        track.addListener(proxy);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a track
+     * @param track The old track
+     * @since 12156
+     */
+    public void removeTrack(GpxTrack track) {
+        if (!privateTracks.remove(track)) {
+            throw new IllegalArgumentException(MessageFormat.format("The track was not in this data: {0}", track));
+        }
+        track.removeListener(proxy);
+        fireInvalidate();
+    }
+
+    /**
+     * Gets the list of all routes defined in this data set.
+     * @return The routes
+     * @since 12156
+     */
+    public Collection<GpxRoute> getRoutes() {
+        return Collections.unmodifiableCollection(privateRoutes);
+    }
+
+    /**
+     * Add a new route
+     * @param route The new route
+     * @since 12156
+     */
+    public void addRoute(GpxRoute route) {
+        if (privateRoutes.contains(route)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was already added to this data: {0}", route));
+        }
+        privateRoutes.add(route);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a route
+     * @param route The old route
+     * @since 12156
+     */
+    public void removeRoute(GpxRoute route) {
+        if (!privateRoutes.remove(route)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", route));
+        }
+        fireInvalidate();
+    }
+
+    /**
+     * Gets a list of all way points in this data set.
+     * @return The way points.
+     * @since 12156
+     */
+    public Collection<WayPoint> getWaypoints() {
+        return Collections.unmodifiableCollection(privateWaypoints);
+    }
+
+    /**
+     * Add a new waypoint
+     * @param waypoint The new waypoint
+     * @since 12156
+     */
+    public void addWaypoint(WayPoint waypoint) {
+        if (privateWaypoints.contains(waypoint)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was already added to this data: {0}", waypoint));
+        }
+        privateWaypoints.add(waypoint);
+        fireInvalidate();
+    }
+
+    /**
+     * Remove a waypoint
+     * @param waypoint The old waypoint
+     * @since 12156
+     */
+    public void removeWaypoint(WayPoint waypoint) {
+        if (!privateWaypoints.remove(waypoint)) {
+            throw new IllegalArgumentException(MessageFormat.format("The route was not in this data: {0}", waypoint));
+        }
+        fireInvalidate();
     }
 
@@ -83 +223 @@
      */
     public boolean hasTrackPoints() {
-        for (GpxTrack trk : tracks) {
-            for (GpxTrackSegment trkseg : trk.getSegments()) {
-                if (!trkseg.getWayPoints().isEmpty())
-                    return true;
-            }
-        }
-        return false;
+        return getTrackPoints().findAny().isPresent();
+    }
+
+    /**
+     * Gets a stream of all track points in the segments of the tracks of this data.
+     * @return The stream
+     * @see #getTracks()
+     * @see GpxTrack#getSegments()
+     * @see GpxTrackSegment#getWayPoints()
+     * @since 12156
+     */
+    public Stream<WayPoint> getTrackPoints() {
+        return getTracks().stream().flatMap(trk -> trk.getSegments().stream()).flatMap(trkseg -> trkseg.getWayPoints().stream());
     }
 
@@ -97 +243 @@
      */
     public boolean hasRoutePoints() {
-        for (GpxRoute rte : routes) {
-            if (!rte.routePoints.isEmpty())
-                return true;
-        }
-        return false;
+        return getRoutes().stream().anyMatch(rte -> !rte.routePoints.isEmpty());
     }
 
@@ -144 +286 @@
     public Bounds recalculateBounds() {
         Bounds bounds = null;
-        for (WayPoint wpt : waypoints) {
+        for (WayPoint wpt : getWaypoints()) {
             if (bounds == null) {
                 bounds = new Bounds(wpt.getCoor());
@@ -151 +293 @@
             }
         }
-        for (GpxRoute rte : routes) {
+        for (GpxRoute rte : getRoutes()) {
             for (WayPoint wpt : rte.routePoints) {
                 if (bounds == null) {
@@ -160 +302 @@
             }
         }
-        for (GpxTrack trk : tracks) {
+        for (GpxTrack trk : getTracks()) {
             Bounds trkBounds = trk.getBounds();
             if (trkBounds != null) {
@@ -178 +320 @@
      */
     public double length() {
-        double result = 0.0; // in meters
-
-        for (GpxTrack trk : tracks) {
-            result += trk.length();
-        }
-
-        return result;
+        return getTracks().stream().mapToDouble(GpxTrack::length).sum();
     }
 
@@ -261 +397 @@
         double py = p.north();
         double rx = 0.0, ry = 0.0, sx, sy, x, y;
-        if (tracks == null)
-            return null;
-        for (GpxTrack track : tracks) {
+        for (GpxTrack track : getTracks()) {
             for (GpxTrackSegment seg : track.getSegments()) {
                 WayPoint r = null;
@@ -352 +486 @@
      */
     public void resetEastNorthCache() {
-        if (waypoints != null) {
-            for (WayPoint wp : waypoints) {
+        getWaypoints().forEach(WayPoint::invalidateEastNorthCache);
+        getTrackPoints().forEach(WayPoint::invalidateEastNorthCache);
+        for (GpxRoute route: getRoutes()) {
+            if (route.routePoints == null) {
+                continue;
+            }
+            for (WayPoint wp: route.routePoints) {
                 wp.invalidateEastNorthCache();
-            }
-        }
-        if (tracks != null) {
-            for (GpxTrack track: tracks) {
-                for (GpxTrackSegment segment: track.getSegments()) {
-                    for (WayPoint wp: segment.getWayPoints()) {
-                        wp.invalidateEastNorthCache();
-                    }
-                }
-            }
-        }
-        if (routes != null) {
-            for (GpxRoute route: routes) {
-                if (route.routePoints == null) {
-                    continue;
-                }
-                for (WayPoint wp: route.routePoints) {
-                    wp.invalidateEastNorthCache();
-                }
             }
         }
@@ -498 +618 @@
         return true;
     }
+
+    /**
+     * Adds a listener that gets called whenever the data changed.
+     * @param listener The listener
+     * @since 12156
+     */
+    public void addChangeListener(GpxDataChangeListener listener) {
+        listeners.addListener(listener);
+    }
+
+    /**
+     * Adds a listener that gets called whenever the data changed. It is added with a weak link
+     * @param listener The listener
+     */
+    public void addWeakChangeListener(GpxDataChangeListener listener) {
+        listeners.addWeakListener(listener);
+    }
+
+    /**
+     * Removes a listener that gets called whenever the data changed.
+     * @param listener The listener
+     * @since 12156
+     */
+    public void removeChangeListener(GpxDataChangeListener listener) {
+        listeners.removeListener(listener);
+    }
+
+    private void fireInvalidate() {
+        GpxDataChangeEvent e = new GpxDataChangeEvent(this);
+        listeners.fireEvent(l -> l.gpxDataChanged(e));
+    }
+
+    /**
+     * This is a proxy of a collection that notifies a listener on every collection change
+     * @author Michael Zangl
+     *
+     * @param <T> The entry type
+     * @since 12156
+     */
+    private static class ListeningCollection<T> extends AbstractCollection<T> {
+        private final ArrayList<T> base;
+        private final Runnable runOnModification;
+
+        ListeningCollection(ArrayList<T> base, Runnable runOnModification) {
+            this.base = base;
+            this.runOnModification = runOnModification;
+        }
+
+        @Override
+        public Iterator<T> iterator() {
+            Iterator<T> it = base.iterator();
+            return new Iterator<T>() {
+                private T cursor;
+
+                @Override
+                public boolean hasNext() {
+                    return it.hasNext();
+                }
+
+                @Override
+                public T next() {
+                    cursor = it.next();
+                    return cursor;
+                }
+
+                @Override
+                public void remove() {
+                    if (cursor != null) {
+                        removed(cursor);
+                        cursor = null;
+                    }
+                    it.remove();
+                }
+            };
+        }
+
+        @Override
+        public int size() {
+            return base.size();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            boolean remove = base.remove(o);
+            if (remove) {
+                removed((T) o);
+            }
+            return remove;
+        }
+
+        @Override
+        public boolean add(T e) {
+            boolean add = base.add(e);
+            added(e);
+            return add;
+        }
+
+        protected void removed(T cursor) {
+            runOnModification.run();
+        }
+
+        protected void added(T cursor) {
+            runOnModification.run();
+        }
+    }
+
+    /**
+     * A listener that listens to GPX data changes.
+     * @author Michael Zangl
+     * @since 12156
+     */
+    @FunctionalInterface
+    public interface GpxDataChangeListener {
+        /**
+         * Called when the gpx data changed.
+         * @param e The event
+         */
+        void gpxDataChanged(GpxDataChangeEvent e);
+    }
+
+    /**
+     * A data change event in any of the gpx data.
+     * @author Michael Zangl
+     * @since 12156
+     */
+    public static class GpxDataChangeEvent {
+        private final GpxData source;
+
+        GpxDataChangeEvent(GpxData source) {
+            super();
+            this.source = source;
+        }
+
+        /**
+         * Get the data that was changed.
+         * @return The data.
+         */
+        public GpxData getSource() {
+            return source;
+        }
+    }
 }

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

@@ -40 +40 @@
      * Returns the number of times this track has been changed.
      * @return Number of times this track has been changed. Always 0 for read-only tracks
+     * @deprecated since 12156 Replaced by change listeners.
      */
-    int getUpdateCount();
+    @Deprecated
+    default int getUpdateCount() {
+        // to allow removal
+        return 0;
+    }
+
+    /**
+     * Add a listener that listens to changes in the GPX track.
+     * @param l The listener
+     */
+    default void addListener(GpxTrackChangeListener l) {
+        // nop
+    }
+
+    /**
+     * Remove a listener that listens to changes in the GPX track.
+     * @param l The listener
+     */
+    default void removeListener(GpxTrackChangeListener l) {
+        // nop
+    }
+
+    /**
+     * A listener that listens to GPX track changes.
+     * @author Michael Zangl
+     * @since 12156
+     */
+    @FunctionalInterface
+    public interface GpxTrackChangeListener {
+        /**
+         * Called when the gpx data changed.
+         * @param e The event
+         */
+        void gpxDataChanged(GpxTrackChangeEvent e);
+    }
+
+    /**
+     * A track change event for the current track.
+     * @author Michael Zangl
+     * @since 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;
+        }
+    }
 }

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

@@ -9 +9 @@
 import java.io.File;
 import java.text.DateFormat;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -60 +59 @@
     /**
      * used by {@link ChooseTrackVisibilityAction} to determine which tracks to show/hide
+     *
+     * Call {@link #invalidate()} after each change!
+     *
+     * TODO: Make it private, make it respond to track changes.
      */
     public boolean[] trackVisibility = new boolean[0];
-
-    private final List<GpxTrack> lastTracks = new ArrayList<>(); // List of tracks at last paint
-    private int lastUpdateCount;
 
     private final GpxDrawHelper drawHelper;
@@ -94 +94 @@
         super(d.getString(GpxConstants.META_NAME));
         data = d;
+        data.addWeakChangeListener(e -> this.invalidate());
         drawHelper = new GpxDrawHelper(data);
         SystemOfMeasurement.addSoMChangeListener(drawHelper);
@@ -151 +152 @@
         }
 
-        if (!data.tracks.isEmpty()) {
+        if (!data.getTracks().isEmpty()) {
             info.append("<table><thead align='center'><tr><td colspan='5'>")
                 .append(trn("{0} track", "{0} tracks", data.tracks.size(), data.tracks.size()))
@@ -159 +160 @@
                 .append("</td></tr></thead>");
 
-            for (GpxTrack trk : data.tracks) {
+            for (GpxTrack trk : data.getTracks()) {
                 info.append("<tr><td>");
                 if (trk.getAttributes().containsKey(GpxConstants.GPX_NAME)) {
@@ -182 +183 @@
 
         info.append(tr("Length: {0}", SystemOfMeasurement.getSystemOfMeasurement().getDistText(data.length()))).append("<br>")
-            .append(trn("{0} route, ", "{0} routes, ", data.routes.size(), data.routes.size()))
-            .append(trn("{0} waypoint", "{0} waypoints", data.waypoints.size(), data.waypoints.size())).append("<br></html>");
+            .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></html>");
 
         final JScrollPane sp = new JScrollPane(new HtmlPanel(info.toString()));
@@ -240 +241 @@
         }
 
-        info.append(trn("{0} track, ", "{0} tracks, ", data.tracks.size(), data.tracks.size()))
-            .append(trn("{0} route, ", "{0} routes, ", data.routes.size(), data.routes.size()))
-            .append(trn("{0} waypoint", "{0} waypoints", data.waypoints.size(), data.waypoints.size())).append("<br>")
+        info.append(trn("{0} track, ", "{0} tracks, ", data.getTracks().size(), data.getTracks().size()))
+            .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>");
@@ -251 +252 @@
     public boolean isMergable(Layer other) {
         return other instanceof GpxLayer;
-    }
-
-    private int sumUpdateCount() {
-        int updateCount = 0;
-        for (GpxTrack track: data.tracks) {
-            updateCount += track.getUpdateCount();
-        }
-        return updateCount;
-    }
-
-    @Override
-    public boolean isChanged() {
-        if (data.tracks.equals(lastTracks))
-            return sumUpdateCount() != lastUpdateCount;
-        else
-            return true;
     }
 
@@ -279 +264 @@
         long from = fromDate.getTime();
         long to = toDate.getTime();
-        for (GpxTrack trk : data.tracks) {
+        for (GpxTrack trk : data.getTracks()) {
             Date[] t = GpxData.getMinMaxTimeForTrack(trk);
 
@@ -287 +272 @@
             i++;
         }
+        invalidate();
     }
 
@@ -299 +285 @@
     @Override
     public void paint(Graphics2D g, MapView mv, Bounds box) {
-        lastUpdateCount = sumUpdateCount();
-        lastTracks.clear();
-        lastTracks.addAll(data.tracks);
-
         List<WayPoint> visibleSegments = listVisibleSegments(box);
         if (!visibleSegments.isEmpty()) {
@@ -363 +345 @@
      */
     private void ensureTrackVisibilityLength() {
-        final int l = data.tracks.size();
+        final int l = data.getTracks().size();
         if (l == trackVisibility.length)
             return;
@@ -371 +353 @@
             trackVisibility[i] = true;
         }
+        invalidate();
     }
 

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

@@ -743 +743 @@
             }
 
-            gpxData.tracks.add(new ImmutableGpxTrack(trk, trkAttr));
+            gpxData.addTrack(new ImmutableGpxTrack(trk, trkAttr));
         });
     }

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

@@ -218 +218 @@
             layer.trackVisibility[table.convertRowIndexToModel(i)] = s.isSelectedIndex(i);
         }
-        Main.map.mapView.preferenceChanged(null);
-        Main.map.repaint(100);
+        layer.invalidate();
     }
 
@@ -292 +291 @@
             layer.trackVisibility[table.convertRowIndexToModel(i)] = all || s.isSelectedIndex(i);
         }
+        // layer has been changed
+        layer.invalidate();
         // ...sync with layer visibility instead to avoid having two ways to hide everything
         layer.setVisible(v == 1 || !s.isSelectionEmpty());

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

@@ -74 +74 @@
         public DataSet convert() {
             final DataSet ds = new DataSet();
-            for (GpxTrack trk : layer.data.tracks) {
+            for (GpxTrack trk : layer.data.getTracks()) {
                 for (GpxTrackSegment segment : trk.getSegments()) {
                     List<Node> nodes = new ArrayList<>();

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

@@ -11 +11 @@
 import org.openstreetmap.josm.Main;
 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.WayPoint;
 import org.openstreetmap.josm.gui.layer.GpxLayer;
 import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer;
@@ -30 +27 @@
     public void actionPerformed(ActionEvent e) {
         GpxData namedTrackPoints = new GpxData();
-        for (GpxTrack track : layer.data.tracks) {
-            for (GpxTrackSegment seg : track.getSegments()) {
-                for (WayPoint point : seg.getWayPoints()) {
-                    if (point.attr.containsKey("name") || point.attr.containsKey("desc")) {
-                        namedTrackPoints.waypoints.add(point);
-                    }
-                }
-            }
-        }
+        layer.data.getTrackPoints()
+            .filter(point -> point.attr.containsKey("name") || point.attr.containsKey("desc"))
+            .forEach(namedTrackPoints.waypoints::add);
         MarkerLayer ml = new MarkerLayer(namedTrackPoints, tr("Named Trackpoints from {0}", layer.getName()), layer.getAssociatedFile(), layer);
         if (!ml.data.isEmpty()) {

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

@@ -317 +317 @@
         WayPoint w2 = null;
 
-        for (GpxTrack track : trackLayer.data.tracks) {
+        for (GpxTrack track : trackLayer.data.getTracks()) {
             for (GpxTrackSegment trackseg : track.getSegments()) {
                 for (WayPoint w: trackseg.getWayPoints()) {

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

@@ -466 +466 @@
                     currentState = states.pop();
                     convertUrlToLink(currentTrackAttr);
-                    data.tracks.add(new ImmutableGpxTrack(currentTrack, currentTrackAttr));
+                    data.addTrack(new ImmutableGpxTrack(currentTrack, currentTrackAttr));
                     break;
                 case "name":
@@ -497 +497 @@
                     currentState = states.pop();
                     convertUrlToLink(currentRoute.attr);
-                    data.routes.add(currentRoute);
+                    data.addRoute(currentRoute);
                     break;
                 default: // Do nothing

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

@@ -186 +186 @@
 
     private void writeWayPoints() {
-        for (WayPoint pnt : data.waypoints) {
+        for (WayPoint pnt : data.getWaypoints()) {
             wayPoint(pnt, WAY_POINT);
         }
@@ -192 +192 @@
 
     private void writeRoutes() {
-        for (GpxRoute rte : data.routes) {
+        for (GpxRoute rte : data.getRoutes()) {
             openln("rte");
             writeAttr(rte, RTE_TRK_KEYS);
@@ -203 +203 @@
 
     private void writeTracks() {
-        for (GpxTrack trk : data.tracks) {
+        for (GpxTrack trk : data.getTracks()) {
             openln("trk");
             writeAttr(trk, RTE_TRK_KEYS);