Changeset 8 in josm for src/org/openstreetmap/josm/data


Ignore:
Timestamp:
2005-10-03T04:18:02+02:00 (15 years ago)
Author:
imi
Message:
  • added Selection Dialog
  • added support for graphic engines with a better default engine
  • reorganized data classes with back references
Location:
src/org/openstreetmap/josm/data
Files:
5 added
6 edited

Legend:

Unmodified
Added
Removed
  • src/org/openstreetmap/josm/data/osm/DataSet.java

    r7 r8  
    22
    33import java.util.Collection;
     4import java.util.Collections;
    45import java.util.HashSet;
    56import java.util.LinkedList;
    67
    78import org.openstreetmap.josm.data.Bounds;
     9import org.openstreetmap.josm.data.SelectionTracker;
    810
    911/**
     
    1719 * @author imi
    1820 */
    19 public class DataSet implements Cloneable {
     21public class DataSet extends SelectionTracker implements Cloneable {
    2022
    2123        /**
     
    3032         * are in this list but are in no track.
    3133         */
    32         public Collection<LineSegment> pendingLineSegments = new LinkedList<LineSegment>();
     34        private Collection<LineSegment> pendingLineSegments = new LinkedList<LineSegment>();
    3335
    3436        /**
     
    3941         * track list.
    4042         */
    41         public Collection<Track> tracks;
     43        private Collection<Track> tracks = new LinkedList<Track>();
     44
     45        /**
     46         * Add the track to the tracklist.
     47         */
     48        public void addTrack(Track t) {
     49                tracks.add(t);
     50        }
     51        /**
     52         * Remove the track from the tracklist.
     53         */
     54        public void removeTrack(Track t) {
     55                t.destroy();
     56                tracks.remove(t);
     57        }
     58        /**
     59         * Return a read-only collection of all tracks
     60         */
     61        public Collection<Track> tracks() {
     62                return Collections.unmodifiableCollection(tracks);
     63        }
     64
     65        /**
     66         * Add a newly created line segment to the pending lines list.
     67         */
     68        public void addPendingLineSegment(LineSegment ls) {
     69                pendingLineSegments.add(ls);
     70        }
     71        /**
     72         * Remove a line segment from the pending lines list, because it has been
     73         * assigned to the track.
     74         * @param ls The line segment from the pending list
     75         * @param t The track, that will hold the line segment
     76         * @param end <code>true</code> to attach on the end. <code>false</code>
     77         *              to attach on the beginning.
     78         */
     79        public void assignPendingLineSegment(LineSegment ls, Track t, boolean end) {
     80                pendingLineSegments.remove(ls);
     81                if (end)
     82                        t.add(ls);
     83                else
     84                        t.addStart(ls);
     85        }
     86        /**
     87         * Delete the pending line segment without moving it anywhere.
     88         */
     89        public void destroyPendingLineSegment(LineSegment ls) {
     90                pendingLineSegments.remove(ls);
     91                ls.destroy();
     92        }
     93        /**
     94         * Return an read-only iterator over all pending line segments.
     95         */
     96        public Collection<LineSegment> pendingLineSegments() {
     97                return Collections.unmodifiableCollection(pendingLineSegments);
     98        }
    4299
    43100        /**
     
    73130
    74131        /**
    75          * Return all tracks that contain the node. If nothing found, an empty array
    76          * is returned.
    77          *
    78          * @param node This node is searched.
    79          * @return All tracks, that reference the node in one of its line segments.
    80          */
    81         public Collection<Track> getReferencedTracks(Node n) {
    82                 Collection<Track> all = new LinkedList<Track>();
    83                 for (Track t : tracks) {
    84                         for (LineSegment ls : t.segments) {
    85                                 if (ls.start == n || ls.end == n) {
    86                                         all.add(t);
    87                                         break;
    88                                 }
    89                         }
    90                 }
    91                 return all;
    92         }
    93        
    94         /**
    95132         * Return the bounds of this DataSet, depending on lat/lon values.
    96133         * The min of the return value is the upper left GeoPoint, the max the lower
     
    131168                clearSelection(tracks);
    132169                for (Track t : tracks)
    133                         clearSelection(t.segments);
     170                        clearSelection(t.segments());
    134171        }
    135172
     
    138175         * @return List of all selected objects.
    139176         */
     177        @Override
    140178        public Collection<OsmPrimitive> getSelected() {
    141179                Collection<OsmPrimitive> sel = getSelected(nodes);
     
    143181                sel.addAll(getSelected(tracks));
    144182                for (Track t : tracks)
    145                         sel.addAll(getSelected(t.segments));
     183                        sel.addAll(getSelected(t.segments()));
    146184                return sel;
    147185        }
    148        
     186
    149187        /**
    150188         * Remove the selection from every value in the collection.
     
    155193                        return;
    156194                for (OsmPrimitive osm : list) {
    157                         osm.selected = false;
     195                        osm.setSelected(false, this);
    158196                        if (osm.keys != null)
    159197                                clearSelection(osm.keys.keySet());
     
    170208                        return sel;
    171209                for (OsmPrimitive osm : list) {
    172                         if (osm.selected)
     210                        if (osm.isSelected())
    173211                                sel.add(osm);
    174212                        if (osm.keys != null)
  • src/org/openstreetmap/josm/data/osm/Key.java

    r7 r8  
    22
    33import java.util.Collection;
     4import java.util.HashMap;
    45import java.util.LinkedList;
     6import java.util.Map;
     7
     8import org.openstreetmap.josm.data.osm.visitor.Visitor;
    59
    610
     
    1519         * The key's name
    1620         */
    17         public String name;
     21        public final String name;
    1822
     23        /**
     24         * All keys are stored here.
     25         */
     26        private static Map<String, Key> allKeys = new HashMap<String, Key>();
     27       
     28        /**
     29         * Generate a key with the given name. You cannot call this directly but
     30         * have to use the static constructor. This makes sure, you get every key
     31         * only once.
     32         */
     33        private Key(String name) {
     34                this.name = name;
     35        }
     36
     37        /**
     38         * Get an instance of the key with the given name.
     39         * @param name  The name of the key to get.
     40         * @return An shared instance of the key with the given name.
     41         */
     42        public static Key get(String name) {
     43                Key key = allKeys.get(name);
     44                if (key == null) {
     45                        key = new Key(name);
     46                        allKeys.put(name, key);
     47                }
     48                return key;
     49        }
     50       
    1951        /**
    2052         * Return an empty list, since keys cannot have nodes.
     
    3971                return name.hashCode();
    4072        }
     73
     74        @Override
     75        public void visit(Visitor visitor) {
     76                visitor.visit(this);
     77        }
    4178}
  • src/org/openstreetmap/josm/data/osm/LineSegment.java

    r7 r8  
    22
    33import java.util.Collection;
     4import java.util.Collections;
    45import java.util.LinkedList;
     6
     7import org.openstreetmap.josm.data.osm.visitor.Visitor;
    58
    69
     
    1316
    1417        /**
     18         * The starting node of the line segment
     19         */
     20        private Node start;
     21       
     22        /**
     23         * The ending node of the line segment
     24         */
     25        private Node end;
     26
     27        /**
     28         * The tracks, this line segment is part of.
     29         */
     30        transient Collection<Track> parent = new LinkedList<Track>();
     31
     32        /**
    1533         * Create an line segment from the given starting and ending node
    1634         * @param start Starting node of the line segment.
     
    2038                this.start = start;
    2139                this.end = end;
     40                start.parentSegment.add(this);
     41                end.parentSegment.add(this);
    2242        }
    2343
    2444        /**
    25          * The starting node of the line segment
     45         * Return all parent tracks this line segment is part of. The list is readonly.
    2646         */
    27         public Node start;
    28        
     47        public Collection<Track> getParents() {
     48                return Collections.unmodifiableCollection(parent);
     49        }
     50
     51        public void setStart(Node start) {
     52                this.start.parentSegment.remove(this);
     53                this.start = start;
     54                start.parentSegment.add(this);
     55        }
     56        public Node getStart() {
     57                return start;
     58        }
     59        public void setEnd(Node end) {
     60                this.end.parentSegment.remove(this);
     61                this.end = end;
     62                end.parentSegment.add(this);
     63        }
     64        public Node getEnd() {
     65                return end;
     66        }
     67
    2968        /**
    30          * The ending node of the line segment
     69         * The LineSegment is going to be destroyed. Unlink all back references.
    3170         */
    32         public Node end;
     71        void destroy() {
     72                start.parentSegment.remove(this);
     73                end.parentSegment.remove(this);
     74        }
    3375
    3476        /**
     
    3880        public Collection<Node> getAllNodes() {
    3981                LinkedList<Node> nodes = new LinkedList<Node>();
    40                 nodes.add(start);
    41                 nodes.add(end);
     82                nodes.add(getStart());
     83                nodes.add(getEnd());
    4284                return nodes;
    4385        }
     
    5294                        return false;
    5395                return super.equals(obj) &&
    54                         start.equals(((LineSegment)obj).start) &&
    55                         end.equals(((LineSegment)obj).end);
     96                        getStart().equals(((LineSegment)obj).getStart()) &&
     97                        getEnd().equals(((LineSegment)obj).getEnd());
    5698        }
    5799
    58100        @Override
    59101        public int hashCode() {
    60                 return super.hashCode() + start.hashCode() + end.hashCode();
     102                return super.hashCode() + getStart().hashCode() + getEnd().hashCode();
     103        }
     104
     105        @Override
     106        public void visit(Visitor visitor) {
     107                visitor.visit(this);
    61108        }
    62109}       
  • src/org/openstreetmap/josm/data/osm/Node.java

    r7 r8  
    22
    33import java.util.Collection;
     4import java.util.Collections;
    45import java.util.LinkedList;
    56
    67import org.openstreetmap.josm.data.GeoPoint;
     8import org.openstreetmap.josm.data.osm.visitor.Visitor;
    79
    810
     
    1921        public GeoPoint coor;
    2022
     23        /**
     24         * The list of line segments, this node is part of.
     25         */
     26        transient Collection<LineSegment> parentSegment = new LinkedList<LineSegment>();
     27
     28        /**
     29         * Returns a read-only list of all segments this node is in.
     30         * @return A list of all segments. Readonly.
     31         */
     32        public Collection<LineSegment> getParentSegments() {
     33                return Collections.unmodifiableCollection(parentSegment);
     34        }
     35       
    2136        /**
    2237         * Nodes are equal when their coordinates are equal.
     
    4964                return nodes;
    5065        }
    51        
    52        
     66
     67        @Override
     68        public void visit(Visitor visitor) {
     69                visitor.visit(this);
     70        }
    5371}
  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r7 r8  
    33import java.util.Collection;
    44import java.util.Map;
     5
     6import org.openstreetmap.josm.data.osm.visitor.Visitor;
    57
    68
     
    2628         * If set to true, this object is currently selected.
    2729         */
    28         transient public boolean selected = false;
     30        transient private boolean selected = false;
    2931
    3032        /**
    3133         * Return a list of all nodes, this osmPrimitive consists of. Does return
    3234         * an empty list, if it is an primitive that cannot have nodes (e.g. Key)
     35         * TODO replace with visitor
    3336         */
    3437        abstract public Collection<Node> getAllNodes();
    3538
     39        /**
     40         * Implementation of the visitor scheme. Subclases have to call the correct
     41         * visitor function.
     42         * @param visitor The visitor from which the visit() function must be called.
     43         */
     44        abstract public void visit(Visitor visitor);
     45       
    3646        /**
    3747         * Return <code>true</code>, if either <code>this.keys</code> and
     
    7989                return keys == null ? 0 : keys.hashCode();
    8090        }
     91
     92        /**
     93         * Mark the primitive as selected or not selected and fires a selection
     94         * changed later, if the value actualy changed.
     95         * @param selected Whether the primitive should be selected or not.
     96         * @param ds The dataSet, this primitive is in.
     97         */
     98        public void setSelected(boolean selected, DataSet ds) {
     99                if (selected != this.selected)
     100                        ds.fireSelectionChanged();
     101                this.selected = selected;
     102        }
     103
     104        /**
     105         * @return Return whether the primitive is selected on screen.
     106         */
     107        public boolean isSelected() {
     108                return selected;
     109        }
    81110}
  • src/org/openstreetmap/josm/data/osm/Track.java

    r7 r8  
    33import java.util.ArrayList;
    44import java.util.Collection;
     5import java.util.Collections;
    56import java.util.List;
     7
     8import org.openstreetmap.josm.data.osm.visitor.Visitor;
    69
    710/**
     
    1518         * All track segments in this track
    1619         */
    17         public final List<LineSegment> segments = new ArrayList<LineSegment>();
     20        private final List<LineSegment> segments = new ArrayList<LineSegment>();
     21
     22       
     23        /**
     24         * Add the line segment to the track.
     25         */
     26        public void add(LineSegment ls) {
     27                segments.add(ls);
     28                ls.parent.add(this);
     29        }
     30
     31        /**
     32         * Add the line segment at first position to the track. First position means,
     33         * the line segment's start becomes the starting node.
     34         * @param ls The line segment to add at starting position.
     35         * @see #getStartingNode()
     36         */
     37        public void addStart(LineSegment ls) {
     38                segments.add(ls);
     39                ls.parent.add(this);
     40        }
     41
     42        /**
     43         * Add all LineSegment's to the list of segments.
     44         * @param lineSegments The line segments to add.
     45         */
     46        public void addAll(Collection<? extends LineSegment> lineSegments) {
     47                segments.addAll(lineSegments);
     48                for (LineSegment ls : lineSegments)
     49                        ls.parent.add(this);
     50        }
     51       
     52        /**
     53         * Remove the line segment from the track.
     54         */
     55        public void remove(LineSegment ls) {
     56                if (segments.remove(ls))
     57                        if (!ls.parent.remove(this))
     58                                throw new IllegalStateException("Parent violation detected.");
     59        }
     60
     61        /**
     62         * Return an read-only collection. Do not alter the object returned.
     63         * @return The read-only Collection of all segments.
     64         */
     65        public Collection<LineSegment> segments() {
     66                return Collections.unmodifiableCollection(segments);
     67        }
    1868
    1969        /**
     
    2676                        nodes.addAll(ls.getAllNodes());
    2777                return nodes;
     78        }
     79        /**
     80         * The track is going to be destroyed. Unlink all back references.
     81         */
     82        void destroy() {
     83                for (LineSegment ls : segments) {
     84                        ls.parent.remove(this);
     85                        if (ls.parent.isEmpty())
     86                                ls.destroy();
     87                }
     88                segments.clear();
    2889        }
    2990
     
    67128                if (segments.isEmpty())
    68129                        return null;
    69                 return segments.get(segments.size()-1).end;
     130                return segments.get(segments.size()-1).getEnd();
     131        }
     132       
     133        /**
     134         * Return the last segment.
     135         * @see #getEndingNode()
     136         */
     137        public LineSegment getEndingSegment() {
     138                if (segments.isEmpty())
     139                        return null;
     140                return segments.get(segments.size()-1);
    70141        }
    71142
     
    82153                if (segments.isEmpty())
    83154                        return null;
    84                 return segments.get(0).start;
     155                return segments.get(0).getStart();
     156        }
     157       
     158        /**
     159         * Return the first segment.
     160         * @see #getStartingNode()
     161         */
     162        public LineSegment getStartingSegment() {
     163                if (segments.isEmpty())
     164                        return null;
     165                return segments.get(0);
     166        }
     167
     168        @Override
     169        public void visit(Visitor visitor) {
     170                visitor.visit(this);
    85171        }
    86172}
Note: See TracChangeset for help on using the changeset viewer.