Changeset 86 in josm


Ignore:
Timestamp:
2006-04-21T14:31:51+02:00 (14 years ago)
Author:
imi
Message:
  • added conflicts and resolve conflict dialog

This is one of those "changed everything" checkpoint.

Files:
15 added
2 deleted
74 edited
1 copied
3 moved

Legend:

Unmodified
Added
Removed
  • .classpath

    r74 r86  
    22<classpath>
    33        <classpathentry kind="src" path="src"/>
    4         <classpathentry kind="src" path="test"/>
    54        <classpathentry including="images/" excluding="*" kind="src" path=""/>
    65        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
  • .settings/org.eclipse.jdt.core.prefs

    r79 r86  
    1 #Mon Apr 03 21:11:54 CEST 2006
     1#Fri Apr 21 12:51:47 CEST 2006
    22eclipse.preferences.version=1
    33org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
     
    6868org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
    6969org.eclipse.jdt.core.formatter.indentation.size=4
    70 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
     70org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=do not insert
    7171org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
    7272org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
  • .settings/org.eclipse.jdt.ui.prefs

    r79 r86  
    1 #Mon Apr 03 21:08:35 CEST 2006
     1#Fri Apr 21 12:51:47 CEST 2006
    22eclipse.preferences.version=1
    33formatter_profile=_josm
  • src/org/openstreetmap/josm/Main.java

    r81 r86  
    7878         * The global dataset.
    7979         */
    80         public DataSet ds = new DataSet();
     80        public static DataSet ds = new DataSet();
    8181       
    8282        /**
     
    176176       
    177177                addWindowListener(new WindowAdapter(){
    178                         @Override
    179                         public void windowClosing(WindowEvent arg0) {
     178                        @Override public void windowClosing(WindowEvent arg0) {
    180179                                if (mapFrame != null) {
    181180                                        boolean modified = false;
     
    217216                        System.out.println();
    218217                        System.out.println("usage:");
    219                         System.out.println("\tjava -jar josm.jar <options>");
     218                        System.out.println("\tjava -jar josm.jar <options> file file file...");
    220219                        System.out.println();
    221220                        System.out.println("options:");
    222221                        System.out.println("\t--help                                  Show this help");
    223222                        System.out.println("\t--download=minlat,minlon,maxlat,maxlon  Download the bounding box");
    224                         System.out.println("\t--open=file(.osm|.xml|.gpx|.txt|.csv)   Open the specific file");
    225223                        System.out.println("\t--no-fullscreen                         Don't launch in fullscreen mode");
    226224                        System.out.println("\t--reset-preferences                     Reset the preferences to default");
     225                        System.out.println("file(.osm|.xml|.gpx|.txt|.csv)            Open the specific file");
    227226                        System.exit(0);
    228227                }
     
    287286                for (Iterator<String> it = arguments.iterator(); it.hasNext();) {
    288287                        String s = it.next();
    289                         if (s.startsWith("--open=")) {
    290                                 main.openAction.openFile(new File(s.substring(7)));
    291                                 it.remove();
    292                         } else if (s.startsWith("--download=")) {
     288                        if (s.startsWith("--download=")) {
    293289                                downloadFromParamString(false, s.substring(11));
    294290                                it.remove();
     
    299295                }
    300296               
    301                 if (!arguments.isEmpty()) {
    302                         String s = "Unknown Parameter:\n";
    303                         for (String arg : arguments)
    304                                 s += arg+"\n";
    305                         JOptionPane.showMessageDialog(main, s);
    306                 }
     297                for (String s : arguments)
     298                        main.openAction.openFile(new File(s));
    307299        }
    308300
  • src/org/openstreetmap/josm/actions/DiskAccessAction.java

    r79 r86  
    2828         */
    2929        protected boolean isDataSetEmpty() {
    30                 for (OsmPrimitive osm : Main.main.ds.allNonDeletedPrimitives())
    31                         if (!osm.isDeleted() || osm.id > 0)
     30                for (OsmPrimitive osm : Main.ds.allNonDeletedPrimitives())
     31                        if (!osm.deleted || osm.id > 0)
    3232                                return false;
    3333                return true;
  • src/org/openstreetmap/josm/actions/DownloadAction.java

    r83 r86  
    6969            }
    7070
    71             @Override
    72             public void realRun() throws IOException, SAXException {
     71            @Override public void realRun() throws IOException, SAXException {
    7372                dataSet = reader.parseOsm();
    7473                if (dataSet == null)
     
    7877            }
    7978
    80                 @Override
    81         protected void finish() {
     79                @Override protected void finish() {
    8280                        if (dataSet == null)
    8381                                return; // user cancelled download or error occoured
     
    10199            }
    102100
    103             @Override
    104             public void realRun() throws IOException, JDOMException {
     101            @Override public void realRun() throws IOException, JDOMException {
    105102                rawData = reader.parseRawGps();
    106103            }
    107104
    108                 @Override
    109         protected void finish() {
     105                @Override protected void finish() {
    110106                        if (rawData == null)
    111107                                return;
     
    188184                dlg.add(osmUrl, GBC.eop().fill(GBC.HORIZONTAL));
    189185                final KeyListener osmUrlRefresher = new KeyAdapter(){
    190                         @Override
    191                         public void keyTyped(KeyEvent e) {
     186                        @Override public void keyTyped(KeyEvent e) {
    192187                                SwingUtilities.invokeLater(new Runnable() {
    193188                                        public void run() {
     
    223218                SwingUtilities.invokeLater(new Runnable() {public void run() {osmUrlRefresher.keyTyped(null);}});
    224219                osmUrl.addKeyListener(new KeyAdapter(){
    225                         @Override
    226                         public void keyTyped(KeyEvent e) {
     220                        @Override public void keyTyped(KeyEvent e) {
    227221                                SwingUtilities.invokeLater(new Runnable() {
    228222                                        public void run() {
  • src/org/openstreetmap/josm/actions/ExtensionFileFilter.java

    r51 r86  
    4545        }
    4646
    47         @Override
    48         public boolean accept(File pathname) {
     47        @Override public boolean accept(File pathname) {
    4948                if (pathname.isDirectory())
    5049                        return true;
     
    5251        }
    5352
    54         @Override
    55         public String getDescription() {
     53        @Override public String getDescription() {
    5654                return description;
    5755        }
  • src/org/openstreetmap/josm/actions/GpxExportAction.java

    r79 r86  
    121121                                w.output(((RawGpsDataLayer)layer).data);
    122122                        else
    123                                 w.output(Main.main.ds);
     123                                w.output(Main.ds);
    124124                        out.close();
    125125                } catch (IOException x) {
  • src/org/openstreetmap/josm/actions/SaveAction.java

    r78 r86  
    1414
    1515import org.openstreetmap.josm.Main;
    16 import org.openstreetmap.josm.data.osm.LineSegment;
     16import org.openstreetmap.josm.data.osm.Segment;
    1717import org.openstreetmap.josm.io.GpxWriter;
    1818import org.openstreetmap.josm.io.OsmWriter;
     
    4141                if (isDataSetEmpty() && JOptionPane.NO_OPTION == JOptionPane.showConfirmDialog(Main.main, "The document contains no data. Save anyway?", "Empty document", JOptionPane.YES_NO_OPTION))
    4242                        return;
     43                if (!Main.main.getMapFrame().conflictDialog.conflicts.isEmpty()) {
     44                        int answer = JOptionPane.showConfirmDialog(Main.main,
     45                                        "There are unresolved conflicts. Conflicts will not be saved and handled as if you rejected all. Continue?", "Conflicts", JOptionPane.YES_NO_OPTION);
     46                        if (answer != JOptionPane.YES_OPTION)
     47                                return;
     48                }
    4349
    4450                JFileChooser fc = createAndOpenFileChooser(false, false);
     
    6066                        FileWriter fileWriter;
    6167                        if (ExtensionFileFilter.filters[ExtensionFileFilter.GPX].acceptName(fn)) {
    62                                 for (LineSegment ls : Main.main.ds.lineSegments) {
     68                                for (Segment ls : Main.ds.segments) {
    6369                                        if (ls.incomplete) {
    6470                                                JOptionPane.showMessageDialog(Main.main, "Export of data containing incomplete ways to GPX is not implemented.\nBe aware, that in future versions of JOSM, GPX support will be kept at a minimum.\nPlease use .osm or .xml as extension for the better OSM support.");
     
    6672                                        }
    6773                                }
    68                                 new GpxWriter(fileWriter = new FileWriter(file), Main.main.ds).output();
     74                                new GpxWriter(fileWriter = new FileWriter(file), Main.ds).output();
    6975                        } else if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(fn))
    70                                 OsmWriter.output(fileWriter = new FileWriter(file), Main.main.ds, false);
     76                                OsmWriter.output(fileWriter = new FileWriter(file), Main.ds, false);
    7177                        else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(fn)) {
    7278                                JOptionPane.showMessageDialog(Main.main, "CSV output not supported yet.");
  • src/org/openstreetmap/josm/actions/UploadAction.java

    r81 r86  
    5858                final Collection<OsmPrimitive> update = new LinkedList<OsmPrimitive>();
    5959                final Collection<OsmPrimitive> delete = new LinkedList<OsmPrimitive>();
    60                 for (OsmPrimitive osm : Main.main.ds.allPrimitives()) {
    61                         if (osm.id == 0 && !osm.isDeleted())
     60                for (OsmPrimitive osm : Main.ds.allPrimitives()) {
     61                        if (osm.id == 0 && !osm.deleted)
    6262                                add.add(osm);
    63                         else if ((osm.modified || osm.modifiedProperties) && !osm.isDeleted())
     63                        else if (osm.modified && !osm.deleted)
    6464                                update.add(osm);
    65                         else if (osm.isDeleted() && osm.id != 0)
     65                        else if (osm.deleted && osm.id != 0)
    6666                                delete.add(osm);
    6767                }
     
    7777               
    7878                PleaseWaitRunnable uploadTask = new PleaseWaitRunnable("Uploading data"){
    79                                 @Override
    80                                 protected void realRun() throws JDOMException {
     79                                @Override protected void realRun() throws JDOMException {
    8180                                        server.uploadOsm(all);
    8281                                }
    83                                 @Override
    84                     protected void finish() {
     82                                @Override protected void finish() {
    8583                                        Main.main.getMapFrame().mapView.editLayer().cleanData(server.processed, !add.isEmpty());
    8684                    }
  • src/org/openstreetmap/josm/actions/WmsServerAction.java

    r79 r86  
    3131                        if (mv.getAllLayers().size() == 1) {
    3232                            Main.main.setMapFrame(null);
    33                             Main.main.ds = new DataSet();
     33                            Main.ds = new DataSet();
    3434                        } else
    3535                            mv.removeLayer(l);
  • src/org/openstreetmap/josm/actions/mapmode/AddNodeAction.java

    r71 r86  
    2727        }
    2828
    29         @Override
    30         public void registerListener() {
     29        @Override public void registerListener() {
    3130                super.registerListener();
    3231                mv.addMouseListener(this);
    3332        }
    3433
    35         @Override
    36         public void unregisterListener() {
     34        @Override public void unregisterListener() {
    3735                super.unregisterListener();
    3836                mv.removeMouseListener(this);
     
    4341         * position.
    4442         */
    45         @Override
    46         public void mouseClicked(MouseEvent e) {
     43        @Override public void mouseClicked(MouseEvent e) {
    4744                if (e.getButton() == MouseEvent.BUTTON1) {
    4845                        Node node = new Node(mv.getLatLon(e.getX(), e.getY()));
     
    5148                                return;
    5249                        }
    53                         mv.editLayer().add(new AddCommand(Main.main.ds, node));
     50                        mv.editLayer().add(new AddCommand(Main.ds, node));
    5451                        mv.repaint();
    5552                }
  • src/org/openstreetmap/josm/actions/mapmode/AddSegmentAction.java

    r84 r86  
    1111import org.openstreetmap.josm.Main;
    1212import org.openstreetmap.josm.command.AddCommand;
    13 import org.openstreetmap.josm.data.osm.LineSegment;
     13import org.openstreetmap.josm.data.osm.Segment;
    1414import org.openstreetmap.josm.data.osm.Node;
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1717
    1818/**
    19  * The user can add a new line segment between two nodes by pressing on the
     19 * The user can add a new segment between two nodes by pressing on the
    2020 * starting node and dragging to the ending node.
    2121 *
    22  * No line segment can be created if there is already a line segment containing
     22 * No segment can be created if there is already a segment containing
    2323 * both nodes.
    2424 *
    2525 * @author imi
    2626 */
    27 public class AddLineSegmentAction extends MapMode implements MouseListener {
     27public class AddSegmentAction extends MapMode implements MouseListener {
    2828
    2929        /**
     
    4242       
    4343        /**
    44          * Create a new AddLineSegmentAction.
     44         * Create a new AddSegmentAction.
    4545         * @param mapFrame The MapFrame this action belongs to.
    4646         */
    47         public AddLineSegmentAction(MapFrame mapFrame) {
    48                 super("Add Line Segment", "addlinesegment", "Add a line segment between two nodes.", "G", KeyEvent.VK_G, mapFrame);
     47        public AddSegmentAction(MapFrame mapFrame) {
     48                super("Add segment", "addlinesegment", "Add a segment between two nodes.", "G", KeyEvent.VK_G, mapFrame);
    4949        }
    5050
    51         @Override
    52         public void registerListener() {
     51        @Override public void registerListener() {
    5352                super.registerListener();
    5453                mv.addMouseListener(this);
     
    5655        }
    5756
    58         @Override
    59         public void unregisterListener() {
     57        @Override public void unregisterListener() {
    6058                super.unregisterListener();
    6159                mv.removeMouseListener(this);
     
    6563
    6664       
    67         @Override
    68         public void actionPerformed(ActionEvent e) {
     65        @Override public void actionPerformed(ActionEvent e) {
    6966                super.actionPerformed(e);
    70                 makeLineSegment();
     67                makeSegment();
    7168        }
    7269
     
    7471         * If user clicked on a node, from the dragging with that node.
    7572         */
    76         @Override
    77         public void mousePressed(MouseEvent e) {
     73        @Override public void mousePressed(MouseEvent e) {
    7874                if (e.getButton() != MouseEvent.BUTTON1)
    7975                        return;
     
    9187         * the mouse button now.
    9288         */
    93         @Override
    94         public void mouseDragged(MouseEvent e) {
     89        @Override public void mouseDragged(MouseEvent e) {
    9590                if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 0)
    9691                        return;
     
    107102
    108103        /**
    109          * If left button was released, try to create the line segment.
     104         * If left button was released, try to create the segment.
    110105         */
    111         @Override
    112         public void mouseReleased(MouseEvent e) {
     106        @Override public void mouseReleased(MouseEvent e) {
    113107                if (e.getButton() == MouseEvent.BUTTON1) {
    114                         makeLineSegment();
    115                         first = null; // release line segment drawing
     108                        makeSegment();
     109                        first = null; // release segment drawing
    116110                }
    117111        }
    118112
    119113        /**
    120          * Create the line segment if first and second are different and there is
    121          * not already a line segment.
     114         * Create the segment if first and second are different and there is
     115         * not already a segment.
    122116         */
    123         private void makeLineSegment() {
     117        private void makeSegment() {
    124118                if (first == null || second == null) {
    125119                        first = null;
     
    136130               
    137131                if (start != end) {
    138                         // try to find a line segment
    139                         for (LineSegment ls : Main.main.ds.lineSegments)
     132                        // try to find a segment
     133                        for (Segment ls : Main.ds.segments)
    140134                                if ((start == ls.from && end == ls.to) || (end == ls.from && start == ls.to))
    141                                         return; // already a line segment here - be happy, do nothing.
     135                                        return; // already a segment here - be happy, do nothing.
    142136
    143                         LineSegment ls = new LineSegment(start, end);
    144                         mv.editLayer().add(new AddCommand(Main.main.ds, ls));
     137                        Segment ls = new Segment(start, end);
     138                        mv.editLayer().add(new AddCommand(Main.ds, ls));
    145139                }
    146140
  • src/org/openstreetmap/josm/actions/mapmode/AddWayAction.java

    r68 r86  
    1111import org.openstreetmap.josm.Main;
    1212import org.openstreetmap.josm.command.AddCommand;
    13 import org.openstreetmap.josm.data.osm.LineSegment;
     13import org.openstreetmap.josm.data.osm.Segment;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1515import org.openstreetmap.josm.data.osm.Way;
     
    1717
    1818/**
    19  * Add a new way from all selected line segments.
     19 * Add a new way from all selected segments.
    2020 *
    21  * If there is a selection when the mode is entered, all line segments in this
     21 * If there is a selection when the mode is entered, all segments in this
    2222 * selection form a new way, except the user holds down Shift.
    2323 *
    24  * The user can click on a line segment. If he holds down Shift, no way is
     24 * The user can click on a segment. If he holds down Shift, no way is
    2525 * created yet. If he holds down Alt, the whole way is considered instead of
    26  * the clicked line segment. If the user holds down Ctrl, no way is created
    27  * and the clicked line segment get removed from the list.
     26 * the clicked segment. If the user holds down Ctrl, no way is created
     27 * and the clicked segment get removed from the list.
    2828 *
    2929 * Also, the user may select a rectangle as in selection mode. No node, area or
     
    4747        }
    4848
    49         @Override
    50         public void actionPerformed(ActionEvent e) {
     49        @Override public void actionPerformed(ActionEvent e) {
    5150                makeWay();
    5251                super.actionPerformed(e);
     
    5857         */
    5958        private void makeWay() {
    60                 Collection<OsmPrimitive> selection = Main.main.ds.getSelected();
     59                Collection<OsmPrimitive> selection = Main.ds.getSelected();
    6160                if (selection.isEmpty())
    6261                        return;
    6362
    6463                // form a new way
    65                 LinkedList<LineSegment> lineSegments = new LinkedList<LineSegment>();
     64                LinkedList<Segment> segments = new LinkedList<Segment>();
    6665                int numberOfSelectedWays = 0;
    6766                for (OsmPrimitive osm : selection) {
    6867                        if (osm instanceof Way)
    6968                                numberOfSelectedWays++;
    70                         else if (osm instanceof LineSegment)
    71                                 lineSegments.add((LineSegment)osm);
     69                        else if (osm instanceof Segment)
     70                                segments.add((Segment)osm);
    7271                }
    7372               
     
    8180                                for (OsmPrimitive osm : selection)
    8281                                        if (osm instanceof Way)
    83                                                 lineSegments.addAll(((Way)osm).segments);
     82                                                segments.addAll(((Way)osm).segments);
    8483                        }
    8584                }
    8685               
    87                 // sort the line segments in best possible order. This is done by:
     86                // sort the segments in best possible order. This is done by:
    8887                // 0  if no elements in list, quit
    8988                // 1  taking the first ls as pivot, remove it from list
     
    9190                // 3  if found, attach it, remove it from list, goto 2
    9291                // 4  if not found, save the pivot-string and goto 0
    93                 LinkedList<LineSegment> sortedLineSegments = new LinkedList<LineSegment>();
    94                 while (!lineSegments.isEmpty()) {
    95                         LinkedList<LineSegment> pivotList = new LinkedList<LineSegment>();
    96                         pivotList.add(lineSegments.getFirst());
    97                         lineSegments.removeFirst();
     92                LinkedList<Segment> sortedSegments = new LinkedList<Segment>();
     93                while (!segments.isEmpty()) {
     94                        LinkedList<Segment> pivotList = new LinkedList<Segment>();
     95                        pivotList.add(segments.getFirst());
     96                        segments.removeFirst();
    9897                        for (boolean found = true; found;) {
    9998                                found = false;
    100                                 for (Iterator<LineSegment> it = lineSegments.iterator(); it.hasNext();) {
    101                                         LineSegment ls = it.next();
     99                                for (Iterator<Segment> it = segments.iterator(); it.hasNext();) {
     100                                        Segment ls = it.next();
    102101                                        if (ls.incomplete)
    103102                                                continue; // incomplete segments are never added to a new way
     
    113112                                }
    114113                        }
    115                         sortedLineSegments.addAll(pivotList);
     114                        sortedSegments.addAll(pivotList);
    116115                }
    117116               
    118117                Way t = new Way();
    119                 t.segments.addAll(sortedLineSegments);
    120                 mv.editLayer().add(new AddCommand(Main.main.ds, t));
    121                 Main.main.ds.clearSelection();
     118                t.segments.addAll(sortedSegments);
     119                mv.editLayer().add(new AddCommand(Main.ds, t));
     120                Main.ds.clearSelection();
    122121                mv.repaint();
    123122        }
  • src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

    r71 r86  
    2626 * @see #deleteWithReferences(OsmPrimitive)
    2727 *
    28  * Pressing Alt will select the way instead of a line segment, as usual.
     28 * Pressing Alt will select the way instead of a segment, as usual.
    2929 *
    3030 * If the user did not press Ctrl and the object has any references, the user
     
    4646        }
    4747
    48         @Override
    49         public void registerListener() {
     48        @Override public void registerListener() {
    5049                super.registerListener();
    5150                mv.addMouseListener(this);
    5251        }
    5352
    54         @Override
    55         public void unregisterListener() {
     53        @Override public void unregisterListener() {
    5654                super.unregisterListener();
    5755                mv.removeMouseListener(this);
     
    5957
    6058       
    61         @Override
    62         public void actionPerformed(ActionEvent e) {
     59        @Override public void actionPerformed(ActionEvent e) {
    6360                super.actionPerformed(e);
    6461                boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
    6562                if (ctrl)
    66                         deleteWithReferences(Main.main.ds.getSelected());
     63                        deleteWithReferences(Main.ds.getSelected());
    6764                else
    68                         delete(Main.main.ds.getSelected(), false);
     65                        delete(Main.ds.getSelected(), false);
    6966                mv.repaint();
    7067        }
     
    7471         * position.
    7572         */
    76         @Override
    77         public void mouseClicked(MouseEvent e) {
     73        @Override public void mouseClicked(MouseEvent e) {
    7874                if (e.getButton() != MouseEvent.BUTTON1)
    7975                        return;
     
    9490         * Delete the primitives and everything they references.
    9591         *
    96          * If a node is deleted, the node and all line segments, ways and areas
     92         * If a node is deleted, the node and all segments, ways and areas
    9793         * the node is part of are deleted as well.
    9894         *
    99          * If a line segment is deleted, all ways the line segment is part of
     95         * If a segment is deleted, all ways the segment is part of
    10096         * are deleted as well. No nodes are deleted.
    10197         *
    102          * If a way is deleted, only the way and no line segments or nodes are
     98         * If a way is deleted, only the way and no segments or nodes are
    10399         * deleted.
    104100         *
     
    110106                Collection<Command> deleteCommands = new LinkedList<Command>();
    111107                for (OsmPrimitive osm : selection)
    112                         deleteCommands.add(new DeleteCommand(Main.main.ds, osm));
     108                        deleteCommands.add(new DeleteCommand(osm));
    113109                if (!deleteCommands.isEmpty())
    114110                        mv.editLayer().add(new SequenceCommand(deleteCommands));
     
    126122                Collection<Command> deleteCommands = new LinkedList<Command>();
    127123                for (OsmPrimitive osm : selection) {
    128                         CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.main.ds);
     124                        CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    129125                        osm.visit(v);
    130126                        if (!selection.containsAll(v.data)) {
     
    132128                                        JOptionPane.showMessageDialog(Main.main, "This object is in use.");
    133129                        } else
    134                                 deleteCommands.add(new DeleteCommand(Main.main.ds, osm));
     130                                deleteCommands.add(new DeleteCommand(osm));
    135131                }
    136132                if (!deleteCommands.isEmpty())
  • src/org/openstreetmap/josm/actions/mapmode/MapMode.java

    r68 r86  
    1414/**
    1515 * A class implementing MapMode is able to be selected as an mode for map editing.
    16  * As example scrolling the map is a MapMode, connecting Nodes to new LineSegments
     16 * As example scrolling the map is a MapMode, connecting Nodes to new Segments
    1717 * is another.
    1818 *
  • src/org/openstreetmap/josm/actions/mapmode/MoveAction.java

    r71 r86  
    55import java.awt.event.KeyEvent;
    66import java.awt.event.MouseEvent;
     7import java.util.Arrays;
    78import java.util.Collection;
    89
     
    5152        }
    5253
    53         @Override
    54         public void registerListener() {
     54        @Override public void registerListener() {
    5555                super.registerListener();
    5656                mv.addMouseListener(this);
     
    5858        }
    5959
    60         @Override
    61         public void unregisterListener() {
     60        @Override public void unregisterListener() {
    6261                super.unregisterListener();
    6362                mv.removeMouseListener(this);
     
    7069         * objects.
    7170         */
    72         @Override
    73         public void mouseDragged(MouseEvent e) {
     71        @Override public void mouseDragged(MouseEvent e) {
    7472                if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 0)
    7573                        return;
     
    8785                        return;
    8886
    89                 Collection<OsmPrimitive> selection = Main.main.ds.getSelected();
     87                Collection<OsmPrimitive> selection = Main.ds.getSelected();
    9088                Collection<Node> affectedNodes = AllNodesVisitor.getAllNodes(selection);
    9189               
     
    117115         * cursor to movement.
    118116         */
    119         @Override
    120         public void mousePressed(MouseEvent e) {
     117        @Override public void mousePressed(MouseEvent e) {
    121118                if (e.getButton() != MouseEvent.BUTTON1)
    122119                        return;
    123120
    124                 if (Main.main.ds.getSelected().size() == 0) {
     121                if (Main.ds.getSelected().size() == 0) {
    125122                        OsmPrimitive osm = mv.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
    126123                        if (osm != null)
    127                                 osm.setSelected(true);
     124                                Main.ds.setSelected(Arrays.asList(new OsmPrimitive[]{osm}));
    128125                        singleOsmPrimitive = osm;
    129126                        mv.repaint();
     
    139136         * Restore the old mouse cursor.
    140137         */
    141         @Override
    142         public void mouseReleased(MouseEvent e) {
     138        @Override public void mouseReleased(MouseEvent e) {
    143139                mv.setCursor(oldCursor);
    144140                if (singleOsmPrimitive != null) {
    145                         singleOsmPrimitive.setSelected(false);
     141                        Main.ds.clearSelection();
    146142                        mv.repaint();
    147143                }
  • src/org/openstreetmap/josm/actions/mapmode/SelectionAction.java

    r71 r86  
    44import java.awt.event.KeyEvent;
    55import java.util.Collection;
     6import java.util.LinkedList;
    67
    78import org.openstreetmap.josm.Main;
     
    4344 * pixel are considered "only click". If that happens, the nearest Node will
    4445 * be selected if there is any within 10 pixel range. If there is no Node within
    45  * 10 pixel, the nearest LineSegment (or Street, if user hold down the Alt-Key)
    46  * within 10 pixel range is selected. If there is no LineSegment within 10 pixel
     46 * 10 pixel, the nearest Segment (or Street, if user hold down the Alt-Key)
     47 * within 10 pixel range is selected. If there is no Segment within 10 pixel
    4748 * and the user clicked in or 10 pixel away from an area, this area is selected.
    4849 * If there is even no area, nothing is selected. Shift and Ctrl key applies to
     
    6768        }
    6869
    69         @Override
    70         public void registerListener() {
     70        @Override public void registerListener() {
    7171                super.registerListener();
    7272                selectionManager.register(mv);
    7373        }
    7474
    75         @Override
    76         public void unregisterListener() {
     75        @Override public void unregisterListener() {
    7776                super.unregisterListener();
    7877                selectionManager.unregister(mv);
     
    8786                        return; // not allowed together
    8887
     88                Collection<OsmPrimitive> curSel;
    8989                if (!ctrl && !shift)
    90                         Main.main.ds.clearSelection(); // new selection will replace the old.
     90                        curSel = new LinkedList<OsmPrimitive>(); // new selection will replace the old.
     91                else
     92                        curSel = Main.ds.getSelected();
    9193
    9294                Collection<OsmPrimitive> selectionList = selectionManager.getObjectsInRectangle(r,alt);
    9395                for (OsmPrimitive osm : selectionList)
    94                         osm.setSelected(!ctrl);
     96                        if (ctrl)
     97                                curSel.remove(osm);
     98                        else
     99                                curSel.add(osm);
     100                Main.ds.setSelected(curSel);
    95101                mv.repaint();
    96102        }
  • src/org/openstreetmap/josm/actions/mapmode/ZoomAction.java

    r71 r86  
    5757        }
    5858
    59         @Override
    60         public void registerListener() {
     59        @Override public void registerListener() {
    6160                super.registerListener();
    6261                selectionManager.register(mv);
    6362        }
    6463
    65         @Override
    66         public void unregisterListener() {
     64        @Override public void unregisterListener() {
    6765                super.unregisterListener();
    6866                selectionManager.unregister(mv);
  • src/org/openstreetmap/josm/command/AddCommand.java

    r40 r86  
    1414 * @author imi
    1515 */
    16 public class AddCommand implements Command {
     16public class AddCommand extends Command {
    1717
    1818        /**
     
    3434        }
    3535
    36         public void executeCommand() {
     36        @Override public void executeCommand() {
    3737                osm.visit(new AddVisitor(ds));
    3838        }
    3939
    40         public void undoCommand() {
     40        @Override public void undoCommand() {
    4141                osm.visit(new DeleteVisitor(ds));
    4242        }
    4343
    44         public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
     44        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    4545                added.add(osm);
    4646        }
  • src/org/openstreetmap/josm/command/ChangePropertyCommand.java

    r84 r86  
    22
    33import java.util.Collection;
    4 import java.util.HashMap;
    5 import java.util.Iterator;
    64import java.util.LinkedList;
    75import java.util.List;
    8 import java.util.Map;
    96
    107import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1613 * @author imi
    1714 */
    18 public class ChangeKeyValueCommand implements Command {
     15public class ChangePropertyCommand extends Command {
    1916
    2017        /**
     
    3330        private final String value;
    3431       
    35         /**
    36          * These are the old values of the objects to do a proper undo.
    37          */
    38         private List<Map<String, String>> oldProperties;
    39        
    40         /**
    41          * These are the old modified states of the data.
    42          */
    43         private List<Boolean> oldModified = new LinkedList<Boolean>();
    44 
    45         public ChangeKeyValueCommand(Collection<OsmPrimitive> objects, String key, String value) {
     32        public ChangePropertyCommand(Collection<OsmPrimitive> objects, String key, String value) {
    4633                this.objects = new LinkedList<OsmPrimitive>(objects);
    4734                this.key = key;
     
    4936        }
    5037       
    51         public void executeCommand() {
    52                 // save old
    53                 oldProperties = new LinkedList<Map<String, String>>();
    54                 for (OsmPrimitive osm : objects) {
    55                         oldProperties.add(osm.keys == null ? null : new HashMap<String, String>(osm.keys));
    56                         oldModified.add(osm.modifiedProperties);
    57                         osm.modifiedProperties = true;
    58                 }
    59 
     38        @Override public void executeCommand() {
     39                super.executeCommand(); // save old
    6040                if (value == null) {
    6141                        for (OsmPrimitive osm : objects)
     
    6747        }
    6848
    69         public void undoCommand() {
    70                 Iterator<Map<String, String>> it = oldProperties.iterator();
    71                 Iterator<Boolean> itMod = oldModified.iterator();
    72                 for (OsmPrimitive osm : objects) {
    73                         osm.keys = it.next();
    74                         osm.modifiedProperties = itMod.next();
    75                 }
    76         }
    77 
    78         public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
     49        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    7950                modified.addAll(objects);
    8051        }
  • src/org/openstreetmap/josm/command/Command.java

    r31 r86  
    22
    33import java.util.Collection;
     4import java.util.HashSet;
     5import java.util.Map.Entry;
    46
    57import org.openstreetmap.josm.data.osm.OsmPrimitive;
     8import org.openstreetmap.josm.data.osm.visitor.CloneVisitor;
    69
    710
     
    1619 * @author imi
    1720 */
    18 public interface Command {
     21abstract public class Command {
    1922
     23        private CloneVisitor orig;
     24       
    2025        /**
    21          * Executes the command on the dataset.
     26         * Executes the command on the dataset. This implementation will remember all
     27         * primitives returned by fillModifiedData for restoring them on undo.
    2228         */
    23         void executeCommand();
     29        public void executeCommand() {
     30                orig = new CloneVisitor();
     31                Collection<OsmPrimitive> all = new HashSet<OsmPrimitive>();
     32                fillModifiedData(all, all, all);
     33                for (OsmPrimitive osm : all)
     34                        osm.visit(orig);
     35        }
    2436
    2537        /**
     
    2739         * It can be assumed, that all objects are in the same state they were before.
    2840         * It can also be assumed that executeCommand was called exactly once before.
     41         *
     42         * This implementation undoes all objects stored by a former call to executeCommand.
    2943         */
    30         void undoCommand();
    31        
     44        public void undoCommand() {
     45                for (Entry<OsmPrimitive, OsmPrimitive> e : orig.orig.entrySet())
     46                        e.getKey().cloneFrom(e.getValue());
     47        }
     48
    3249        /**
    3350         * Fill in the changed data this command operates on.
     
    3855         * @param added         The added primitives
    3956         */
    40         void fillModifiedData(Collection<OsmPrimitive> modified,
     57        abstract public void fillModifiedData(Collection<OsmPrimitive> modified,
    4158                        Collection<OsmPrimitive> deleted,
    4259                        Collection<OsmPrimitive> added);
  • src/org/openstreetmap/josm/command/DeleteCommand.java

    r40 r86  
    44import java.util.HashSet;
    55
    6 import org.openstreetmap.josm.data.osm.DataSet;
     6import org.openstreetmap.josm.Main;
    77import org.openstreetmap.josm.data.osm.OsmPrimitive;
    88import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
     
    1212 * @author imi
    1313 */
    14 public class DeleteCommand implements Command {
     14public class DeleteCommand extends Command {
    1515
    16         /**
    17          * The dataset this command operates on.
    18          */
    19         final DataSet ds;
    2016        /**
    2117         * The primitive that get deleted.
     
    2319        final Collection<OsmPrimitive> data = new HashSet<OsmPrimitive>();
    2420
    25         public DeleteCommand(DataSet ds, OsmPrimitive osm) {
    26                 this.ds = ds;
    27                 CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(ds);
     21        public DeleteCommand(OsmPrimitive osm) {
     22                CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    2823                osm.visit(v);
    2924                data.addAll(v.data);
     
    3126        }
    3227       
    33         public void executeCommand() {
     28        @Override public void executeCommand() {
     29                super.executeCommand();
    3430                for (OsmPrimitive osm : data)
    35                         osm.setDeleted(true);
     31                        osm.delete(true);
    3632        }
    3733
    38         public void undoCommand() {
    39                 for (OsmPrimitive osm : data)
    40                         osm.setDeleted(false);
    41         }
    42 
    43         public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
     34        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    4435                deleted.addAll(data);
    4536        }
  • src/org/openstreetmap/josm/command/MoveCommand.java

    r73 r86  
    1919 * @author imi
    2020 */
    21 public class MoveCommand implements Command {
     21public class MoveCommand extends Command {
    2222
    2323        /**
     
    8484        }
    8585       
    86         public void executeCommand() {
     86        @Override public void executeCommand() {
    8787                for (Node n : objects) {
    8888                        n.eastNorth = new EastNorth(n.eastNorth.east()+x, n.eastNorth.north()+y);
     
    9292        }
    9393
    94         public void undoCommand() {
     94        @Override public void undoCommand() {
    9595                Iterator<OldState> it = oldState.iterator();
    9696                for (Node n : objects) {
     
    102102        }
    103103
    104         public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
     104        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    105105                for (OsmPrimitive osm : objects)
    106106                        modified.add(osm);
  • src/org/openstreetmap/josm/command/SequenceCommand.java

    r31 r86  
    1010 * @author imi
    1111 */
    12 public class SequenceCommand implements Command {
     12public class SequenceCommand extends Command {
    1313
    1414        /**
     
    2626        }
    2727       
    28         public void executeCommand() {
     28        @Override public void executeCommand() {
    2929                for (Command c : sequenz)
    3030                        c.executeCommand();
    3131        }
    3232
    33         public void undoCommand() {
     33        @Override public void undoCommand() {
    3434                for (int i = sequenz.length-1; i >= 0; --i)
    3535                        sequenz[i].undoCommand();
    3636        }
    3737
    38         public void fillModifiedData(Collection<OsmPrimitive> modified,
    39                         Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
     38        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    4039                for (Command c : sequenz)
    4140                        c.fillModifiedData(modified, deleted, added);
  • src/org/openstreetmap/josm/data/Bounds.java

    r78 r86  
    3535        }
    3636       
    37         @Override
    38         public String toString() {
     37        @Override public String toString() {
    3938                return "Bounds["+min.lat()+","+min.lon()+","+max.lat()+","+max.lon()+"]";
    4039        }
  • src/org/openstreetmap/josm/data/coor/Coordinate.java

    r78 r86  
    5050        }
    5151
    52         @Override
    53         public boolean equals(Object obj) {
     52        @Override public boolean equals(Object obj) {
    5453                return obj instanceof Coordinate ? x == ((Coordinate)obj).x && ((Coordinate)obj).y == y : false;
    5554        }
    5655
    57         @Override
    58         public int hashCode() {
     56        @Override public int hashCode() {
    5957                return (int)(x*65536+y*4096);
    6058        }
  • src/org/openstreetmap/josm/data/coor/EastNorth.java

    r79 r86  
    2222        }
    2323       
    24         @Override
    25         public String toString() {
     24        @Override public String toString() {
    2625                return "EastNorth[e="+x+", n="+y+"]";
    2726        }
  • src/org/openstreetmap/josm/data/coor/LatLon.java

    r79 r86  
    4242        }
    4343
    44     @Override
    45     public String toString() {
     44    @Override public String toString() {
    4645        return "LatLon[lat="+lat()+",lon="+lon()+"]";
    4746    }
  • src/org/openstreetmap/josm/data/osm/DataSet.java

    r78 r86  
    22
    33import java.util.Collection;
     4import java.util.Collections;
    45import java.util.HashSet;
    56import java.util.LinkedList;
    67
    7 import org.openstreetmap.josm.data.SelectionTracker;
     8import org.openstreetmap.josm.data.SelectionChangedListener;
    89
    910/**
     
    1718 * @author imi
    1819 */
    19 public class DataSet extends SelectionTracker {
     20public class DataSet {
    2021
    2122        /**
     
    2728
    2829        /**
    29          * All line segments goes here, even when they are in a way.
     30         * All segments goes here, even when they are in a way.
    3031         */
    31         public Collection<LineSegment> lineSegments = new LinkedList<LineSegment>();
     32        public Collection<Segment> segments = new LinkedList<Segment>();
    3233
    3334        /**
     
    4142
    4243        /**
     44     * A list of listeners to selection changed events.
     45     */
     46    transient Collection<SelectionChangedListener> listeners = new LinkedList<SelectionChangedListener>();
     47
     48        /**
    4349         * @return A collection containing all primitives (except keys) of the
    4450         * dataset.
     
    4753                Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
    4854                o.addAll(nodes);
    49                 o.addAll(lineSegments);
     55                o.addAll(segments);
    5056                o.addAll(ways);
    5157                return o;
     
    5864                Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
    5965                for (OsmPrimitive osm : allPrimitives())
    60                         if (!osm.isDeleted())
     66                        if (!osm.deleted)
    6167                                o.add(osm);
    6268                return o;
     
    6874        public void clearSelection() {
    6975                clearSelection(nodes);
    70                 clearSelection(lineSegments);
     76                clearSelection(segments);
    7177                clearSelection(ways);
     78                Collection<OsmPrimitive> sel = Collections.emptyList();
     79                fireSelectionChanged(sel);
    7280        }
    7381
     
    7684         * @return List of all selected objects.
    7785         */
    78         @Override
    7986        public Collection<OsmPrimitive> getSelected() {
    8087                Collection<OsmPrimitive> sel = getSelected(nodes);
    81                 sel.addAll(getSelected(lineSegments));
     88                sel.addAll(getSelected(segments));
    8289                sel.addAll(getSelected(ways));
    8390                return sel;
    8491        }
    8592
     93        public void setSelected(Collection<OsmPrimitive> selection) {
     94                clearSelection();
     95                for (OsmPrimitive osm : selection)
     96                        osm.selected = true;
     97                fireSelectionChanged(selection);
     98        }
     99       
    86100        /**
    87101         * Remove the selection from every value in the collection.
     
    92106                        return;
    93107                for (OsmPrimitive osm : list)
    94                         osm.setSelected(false);
     108                        osm.selected = false;
    95109        }
    96110
     
    104118                        return sel;
    105119                for (OsmPrimitive osm : list)
    106                         if (osm.isSelected() && !osm.isDeleted())
     120                        if (osm.selected && !osm.deleted)
    107121                                sel.add(osm);
    108122                return sel;
    109123        }
     124
     125        /**
     126     * Remember to fire an selection changed event. A call to this will not fire
     127     * the event immediately. For more, @see SelectionChangedListener
     128     */
     129    private void fireSelectionChanged(Collection<OsmPrimitive> sel) {
     130                for (SelectionChangedListener l : listeners)
     131                        l.selectionChanged(sel);
     132    }
     133
     134        /**
     135     * Add a listener to the selection changed listener list. If <code>null</code>
     136     * is passed, nothing happens.
     137     * @param listener The listener to add to the list.
     138     */
     139    public void addSelectionChangedListener(SelectionChangedListener listener) {
     140        if (listener != null)
     141                listeners.add(listener);
     142    }
     143
     144        /**
     145     * Remove a listener from the selection changed listener list.
     146     * If <code>null</code> is passed, nothing happens.
     147     * @param listener The listener to remove from the list.
     148     */
     149    public void removeSelectionChangedListener(SelectionChangedListener listener) {
     150        if (listener != null)
     151                listeners.remove(listener);
     152    }
    110153}
  • src/org/openstreetmap/josm/data/osm/Node.java

    r73 r86  
    1515       
    1616        public LatLon coor;
    17         public EastNorth eastNorth;
     17        public volatile EastNorth eastNorth;
     18
     19        /**
     20         * Create an identical clone of the argument (including the id)
     21         */
     22        public Node(Node clone) {
     23                cloneFrom(clone);
     24        }
    1825
    1926        public Node(LatLon latlon) {
     
    2229        }
    2330
    24         @Override
    25         public void visit(Visitor visitor) {
     31        @Override public void visit(Visitor visitor) {
    2632                visitor.visit(this);
    2733        }
    2834       
    29         @Override
    30         public String toString() {
    31                 return "{Node id="+id+",lat="+coor.lat()+",lon="+coor.lon()+"}";
    32         }
    33 
    34         @Override
    35         public void cloneFrom(OsmPrimitive osm) {
     35        @Override public void cloneFrom(OsmPrimitive osm) {
    3636                super.cloneFrom(osm);
    3737                coor = ((Node)osm).coor;
    3838                eastNorth = ((Node)osm).eastNorth;
    3939        }
     40
     41        @Override public String toString() {
     42                return "{Node id="+id+",lat="+coor.lat()+",lon="+coor.lon()+"}";
     43        }
     44
     45        @Override public boolean realEqual(OsmPrimitive osm) {
     46                return osm instanceof Node ? super.realEqual(osm) && coor.equals(((Node)osm).coor) : false;
     47    }
    4048}
  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r81 r86  
    88import java.util.Map.Entry;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.osm.visitor.Visitor;
    1211
     
    3837
    3938        /**
    40          * <code>true</code>, if the objects content (not the properties) has been
    41          * modified since it was loaded from the server. In this case, on next upload,
    42          * this object will be updated. Deleted objects are deleted from the server.
    43          * If the objects are added (id=0), the modified is ignored and the object is
    44          * added to the server.
     39         * <code>true</code>, if the object has been modified since it was loaded from
     40         * the server. In this case, on next upload, this object will be updated.
     41         * Deleted objects are deleted from the server. If the objects are added (id=0),
     42         * the modified is ignored and the object is added to the server.
    4543         */
    4644        public boolean modified = false;
    4745
    4846        /**
    49          * <code>true</code>, if the object's keys has been changed by JOSM since
    50          * last update.
    51          */
    52         public boolean modifiedProperties = false;
    53        
    54         /**
    5547         * <code>true</code>, if the object has been deleted.
    5648         */
    57         private boolean deleted = false;
     49        public boolean deleted = false;
    5850
    5951        /**
    6052         * If set to true, this object is currently selected.
    6153         */
    62         private boolean selected = false;
     54        public volatile boolean selected = false;
    6355
    6456        /**
     
    6759         * used to check against edit conflicts.
    6860         */
    69         public Date lastModified = null;
     61        public Date timestamp = null;
    7062
    7163        /**
     
    7668        abstract public void visit(Visitor visitor);
    7769
    78         /**
    79          * Return <code>true</code>, if either <code>this.keys</code> and
    80          * <code>other.keys</code> is <code>null</code> or if they do not share Keys
    81          * with different values.
    82          * 
    83          * @param other         The second key-set to compare with.
    84          * @return      True, if the keysets are mergable
    85          */
    86         final public boolean keyPropertiesMergable(OsmPrimitive other) {
    87                 if ((keys == null) != (other.keys == null))
    88                         return false;
    89 
    90                 if (keys != null) {
    91                         for (String k : keys.keySet())
    92                                 if (other.keys.containsKey(k) && !keys.get(k).equals(other.keys.get(k)))
    93                                         return false;
    94                         for (String k : other.keys.keySet())
    95                                 if (keys.containsKey(k) && !other.keys.get(k).equals(keys.get(k)))
    96                                         return false;
    97                 }
    98                 return true;
    99         }
    100 
    101         /**
    102          * Mark the primitive as selected or not selected and fires a selection
    103          * changed later, if the value actualy changed.
    104          * @param selected Whether the primitive should be selected or not.
    105          */
    106         final public void setSelected(boolean selected) {
    107                 if (selected != this.selected)
    108                         Main.main.ds.fireSelectionChanged();
    109                 this.selected = selected;
    110         }
    111 
    112         /**
    113          * @return Return whether the primitive is selected on screen.
    114          */
    115         final public boolean isSelected() {
    116                 return selected;
    117         }
    118 
    119 
    120         public void setDeleted(boolean deleted) {
     70        public final void delete(boolean deleted) {
    12171                this.deleted = deleted;
    122                 setSelected(false);
    123         }
    124 
    125         public boolean isDeleted() {
    126                 return deleted;
     72                selected = false;
     73                modified = true;
    12774        }
    12875
     
    13380         * An primitive is equal to its incomplete counter part.
    13481         */
    135         @Override
    136         public boolean equals(Object obj) {
     82        @Override public final boolean equals(Object obj) {
    13783                if (obj == null || getClass() != obj.getClass() || id == 0 || ((OsmPrimitive)obj).id == 0)
    13884                        return super.equals(obj);
     
    14591         * An primitive has the same hashcode as its incomplete counter part.
    14692         */
    147         @Override
    148         public int hashCode() {
     93        @Override public final int hashCode() {
    14994                return id == 0 ? super.hashCode() : (int)id;
    15095        }
     
    155100         * @param value The value for the key.
    156101         */
    157         public void put(String key, String value) {
    158                 if (keys == null)
    159                         keys = new HashMap<String, String>();
    160                 keys.put(key, value);
     102        public final void put(String key, String value) {
     103                if (value == null)
     104                        remove(key);
     105                else {
     106                        if (keys == null)
     107                                keys = new HashMap<String, String>();
     108                        keys.put(key, value);
     109                }
    161110        }
    162111        /**
    163112         * Remove the given key from the list.
    164113         */
    165         public void remove(String key) {
     114        public final void remove(String key) {
    166115                if (keys != null) {
    167116                        keys.remove(key);
     
    171120        }
    172121
    173         public String get(String key) {
     122        public final String get(String key) {
    174123                return keys == null ? null : keys.get(key);
    175124        }
    176        
    177         public Collection<Entry<String, String>> entrySet() {
     125
     126        public final Collection<Entry<String, String>> entrySet() {
    178127                if (keys == null)
    179128                        return Collections.emptyList();
     
    181130        }
    182131
    183         public Collection<String> keySet() {
     132        public final Collection<String> keySet() {
    184133                if (keys == null)
    185134                        return Collections.emptyList();
     
    192141         */
    193142        public void cloneFrom(OsmPrimitive osm) {
    194                 keys = osm.keys;
     143                keys = osm.keys == null ? null : new HashMap<String, String>(osm.keys);
    195144                id = osm.id;
    196145                modified = osm.modified;
    197                 modifiedProperties = osm.modifiedProperties;
    198146                deleted = osm.deleted;
    199147                selected = osm.selected;
    200                 lastModified = osm.lastModified;
     148                timestamp = osm.timestamp;
     149        }
     150
     151        /**
     152         * Perform an equality compare for all non-volatile fields not only for the id
     153         * but for the whole object (for conflict resolving etc)
     154         */
     155        public boolean realEqual(OsmPrimitive osm) {
     156                return
     157                id == osm.id &&
     158                modified == osm.modified &&
     159                deleted == osm.deleted &&
     160                (timestamp == null ? osm.timestamp==null : timestamp.equals(osm.timestamp)) &&
     161                (keys == null ? osm.keys==null : keys.equals(osm.keys));
    201162        }
    202163}
  • src/org/openstreetmap/josm/data/osm/Segment.java

    r84 r86  
    55
    66/**
    7  * One way line segment consisting of a pair of nodes (from/to)
     7 * One way segment consisting of a pair of nodes (from/to)
    88 *
    99 * @author imi
    1010 */
    11 public class LineSegment extends OsmPrimitive {
     11public class Segment extends OsmPrimitive {
    1212
    1313        /**
    14          * The starting node of the line segment
     14         * The starting node of the segment
    1515         */
    1616        public Node from;
    1717
    1818        /**
    19          * The ending node of the line segment
     19         * The ending node of the segment
    2020         */
    2121        public Node to;
     
    2828
    2929        /**
    30          * Create an line segment from the given starting and ending node
    31          * @param from  Starting node of the line segment.
    32          * @param to    Ending node of the line segment.
     30         * Create an identical clone of the argument (including the id)
    3331         */
    34         public LineSegment(Node from, Node to) {
     32        public Segment(Segment clone) {
     33                cloneFrom(clone);
     34        }
     35
     36        /**
     37         * Create an segment from the given starting and ending node
     38         * @param from  Starting node of the segment.
     39         * @param to    Ending node of the segment.
     40         */
     41        public Segment(Node from, Node to) {
    3542                this.from = from;
    3643                this.to = to;
     
    3845        }
    3946
    40         public LineSegment(long id) {
     47        public Segment(long id) {
    4148                this.id = id;
    4249                incomplete = true;
    4350        }
    4451
    45         @Override
    46         public void visit(Visitor visitor) {
     52        @Override public void visit(Visitor visitor) {
    4753                visitor.visit(this);
    4854        }
     
    5258         * exactly the same place as <code>this</code>.
    5359         */
    54         public boolean equalPlace(LineSegment ls) {
     60        public boolean equalPlace(Segment ls) {
    5561                if (equals(ls))
    5662                        return true;
     
    6167        }
    6268
    63         @Override
    64         public String toString() {
    65                 String s = "{LineSegment id="+id;
    66                 if (incomplete)
    67                         return s+",incomplete}";
    68                 return s+",from="+from+",to="+to+"}";
    69         }
    70 
    71         @Override
    72         public void cloneFrom(OsmPrimitive osm) {
     69        @Override public void cloneFrom(OsmPrimitive osm) {
    7370                super.cloneFrom(osm);
    74                 LineSegment ls = ((LineSegment)osm);
     71                Segment ls = ((Segment)osm);
    7572                from = ls.from;
    7673                to = ls.to;
    7774                incomplete = ls.incomplete;
    7875        }
     76
     77        @Override public String toString() {
     78                return "{Segment id="+id+" from="+from+" to="+to+"}";
     79        }
     80
     81        @Override public boolean realEqual(OsmPrimitive osm) {
     82                return osm instanceof Segment ?
     83                                super.realEqual(osm) &&
     84                                from.equals(((Segment)osm).from) &&
     85                                to.equals(((Segment)osm).to) : false;
     86        }
    7987}       
  • src/org/openstreetmap/josm/data/osm/Way.java

    r66 r86  
    22
    33import java.util.ArrayList;
     4import java.util.Arrays;
    45import java.util.List;
    56
     
    1617         * All way segments in this way
    1718         */
    18         public final List<LineSegment> segments = new ArrayList<LineSegment>();
     19        public final List<Segment> segments = new ArrayList<Segment>();
    1920
    20         @Override
    21         public void visit(Visitor visitor) {
     21        @Override public void visit(Visitor visitor) {
    2222                visitor.visit(this);
    2323        }
    2424
    25         @Override
    26         public void cloneFrom(OsmPrimitive osm) {
     25        /**
     26         * Create an identical clone of the argument (including the id)
     27         */
     28        public Way(Way clone) {
     29                cloneFrom(clone);
     30        }
     31       
     32        public Way() {
     33        }
     34       
     35        @Override public void cloneFrom(OsmPrimitive osm) {
    2736                super.cloneFrom(osm);
    2837                segments.clear();
    2938                segments.addAll(((Way)osm).segments);
    3039        }
     40
     41    @Override public String toString() {
     42        return "{Way id="+id+" segments="+Arrays.toString(segments.toArray())+"}";
     43    }
     44
     45        @Override public boolean realEqual(OsmPrimitive osm) {
     46                return osm instanceof Way ? super.realEqual(osm) && segments.equals(((Way)osm).segments) : false;
     47    }
    3148}
  • src/org/openstreetmap/josm/data/osm/visitor/AddVisitor.java

    r71 r86  
    44
    55import org.openstreetmap.josm.data.osm.DataSet;
    6 import org.openstreetmap.josm.data.osm.LineSegment;
     6import org.openstreetmap.josm.data.osm.Segment;
    77import org.openstreetmap.josm.data.osm.Node;
    88import org.openstreetmap.josm.data.osm.Way;
     
    2626                ds.nodes.add(n);
    2727        }
    28         public void visit(LineSegment ls) {
    29                 ds.lineSegments.add(ls);
     28        public void visit(Segment ls) {
     29                ds.segments.add(ls);
    3030        }
    3131        public void visit(Way t) {
  • src/org/openstreetmap/josm/data/osm/visitor/AllNodesVisitor.java

    r71 r86  
    44import java.util.HashSet;
    55
    6 import org.openstreetmap.josm.data.osm.LineSegment;
     6import org.openstreetmap.josm.data.osm.Segment;
    77import org.openstreetmap.josm.data.osm.Node;
    88import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    3131         * Line segments have exactly two nodes: from and to.
    3232         */
    33         public void visit(LineSegment ls) {
     33        public void visit(Segment ls) {
    3434                if (!ls.incomplete) {
    3535                        visit(ls.from);
     
    3939
    4040        /**
    41          * Ways have all nodes from their line segments.
     41         * Ways have all nodes from their segments.
    4242         */
    4343        public void visit(Way t) {
    44                 for (LineSegment ls : t.segments)
     44                for (Segment ls : t.segments)
    4545                        visit(ls);
    4646        }
  • src/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitor.java

    r73 r86  
    44import org.openstreetmap.josm.data.Bounds;
    55import org.openstreetmap.josm.data.coor.EastNorth;
    6 import org.openstreetmap.josm.data.osm.LineSegment;
     6import org.openstreetmap.josm.data.osm.Segment;
    77import org.openstreetmap.josm.data.osm.Node;
    88import org.openstreetmap.josm.data.osm.Way;
     
    2121        }
    2222
    23         public void visit(LineSegment ls) {
     23        public void visit(Segment ls) {
    2424                if (!ls.incomplete) {
    2525                        visit(ls.from);
     
    2929
    3030        public void visit(Way t) {
    31                 for (LineSegment ls : t.segments)
     31                for (Segment ls : t.segments)
    3232                        visit(ls);
    3333        }
  • src/org/openstreetmap/josm/data/osm/visitor/CollectBackReferencesVisitor.java

    r71 r86  
    55
    66import org.openstreetmap.josm.data.osm.DataSet;
    7 import org.openstreetmap.josm.data.osm.LineSegment;
     7import org.openstreetmap.josm.data.osm.Segment;
    88import org.openstreetmap.josm.data.osm.Node;
    99import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1111
    1212/**
    13  * Helper that collect all line segments a node is part of, all ways
    14  * a node or line segment is part of and all areas a node is part of.
     13 * Helper that collect all segments a node is part of, all ways
     14 * a node or segment is part of and all areas a node is part of.
    1515 *
    1616 * Deleted objects are not collected.
     
    3838        public void visit(Node n) {
    3939                for (Way t : ds.ways) {
    40                         if (t.isDeleted())
     40                        if (t.deleted)
    4141                                continue;
    42                         for (LineSegment ls : t.segments) {
     42                        for (Segment ls : t.segments) {
    4343                                if (ls.incomplete)
    4444                                        continue;
     
    4949                        }
    5050                }
    51                 for (LineSegment ls : ds.lineSegments) {
    52                         if (ls.isDeleted() || ls.incomplete)
     51                for (Segment ls : ds.segments) {
     52                        if (ls.deleted || ls.incomplete)
    5353                                continue;
    5454                        if (ls.from == n || ls.to == n)
     
    5656                }
    5757        }
    58         public void visit(LineSegment ls) {
     58        public void visit(Segment ls) {
    5959                for (Way t : ds.ways) {
    60                         if (t.isDeleted())
     60                        if (t.deleted)
    6161                                continue;
    6262                        if (t.segments.contains(ls))
  • src/org/openstreetmap/josm/data/osm/visitor/DeleteVisitor.java

    r71 r86  
    44
    55import org.openstreetmap.josm.data.osm.DataSet;
    6 import org.openstreetmap.josm.data.osm.LineSegment;
     6import org.openstreetmap.josm.data.osm.Segment;
    77import org.openstreetmap.josm.data.osm.Node;
    88import org.openstreetmap.josm.data.osm.Way;
     
    2626                ds.nodes.remove(n);
    2727        }
    28         public void visit(LineSegment ls) {
    29                 ds.lineSegments.remove(ls);
     28        public void visit(Segment ls) {
     29                ds.segments.remove(ls);
    3030        }
    3131        public void visit(Way t) {
  • src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

    r71 r86  
    11package org.openstreetmap.josm.data.osm.visitor;
    22
     3import java.util.Collection;
     4import java.util.Date;
    35import java.util.HashMap;
    46import java.util.Iterator;
     
    79
    810import org.openstreetmap.josm.data.osm.DataSet;
    9 import org.openstreetmap.josm.data.osm.LineSegment;
     11import org.openstreetmap.josm.data.osm.Segment;
    1012import org.openstreetmap.josm.data.osm.Node;
    1113import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2022public class MergeVisitor implements Visitor {
    2123
     24        /**
     25         * Map from primitives in the database to visited primitives. (Attention: The other way
     26         * round than mergedNodes and mergedSegments)
     27         */
     28        public Map<OsmPrimitive, OsmPrimitive> conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
     29
    2230        private final DataSet ds;
    23        
     31
    2432        /**
    2533         * A list of all nodes that got replaced with other nodes.
     
    2937        private final Map<Node, Node> mergedNodes = new HashMap<Node, Node>();
    3038        /**
    31          * A list of all line segments that got replaced with others.
     39         * A list of all segments that got replaced with others.
    3240         * Key is the segment in the other's dataset and the value is the one that is now
    33          * in ds.lineSegments.
    34          */
    35         private final Map<LineSegment, LineSegment> mergedLineSegments = new HashMap<LineSegment, LineSegment>();
    36        
     41         * in ds.segments.
     42         */
     43        private final Map<Segment, Segment> mergedSegments = new HashMap<Segment, Segment>();
     44
    3745        public MergeVisitor(DataSet ds) {
    3846                this.ds = ds;
     
    4351         * either id is zero, merge if lat/lon matches.
    4452         */
    45         public void visit(Node otherNode) {
    46                 Node myNode = null;
     53        public void visit(Node other) {
     54                if (mergeAfterId(mergedNodes, ds.nodes, other))
     55                        return;
     56
     57                Node my = null;
    4758                for (Node n : ds.nodes) {
    48                         if (match(n, otherNode)) {
    49                                 myNode = n;
     59                        if (match(n, other)) {
     60                                my = n;
    5061                                break;
    5162                        }
    5263                }
    53                 if (myNode == null)
    54                         ds.nodes.add(otherNode);
     64                if (my == null)
     65                        ds.nodes.add(other);
    5566                else {
    56                         mergedNodes.put(otherNode, myNode);
    57                         mergeCommon(myNode, otherNode);
    58                         if (myNode.modified && !otherNode.modified)
     67                        mergedNodes.put(other, my);
     68                        mergeCommon(my, other);
     69                        if (my.modified && !other.modified)
    5970                                return;
    60                         if (!myNode.coor.equalsEpsilon(otherNode.coor)) {
    61                                 myNode.coor = otherNode.coor;
    62                                 myNode.modified = otherNode.modified;
    63                         }
    64                 }
    65         }
    66 
    67         /**
    68          * Merge the line segment if id matches or if both nodes are the same (and the
     71                        if (!my.coor.equalsEpsilon(other.coor)) {
     72                                my.coor = other.coor;
     73                                my.eastNorth = other.eastNorth;
     74                                my.modified = other.modified;
     75                        }
     76                }
     77        }
     78
     79        /**
     80         * Merge the segment if id matches or if both nodes are the same (and the
    6981         * id is zero of either segment). Nodes are the "same" when they @see match
    7082         */
    71         public void visit(LineSegment otherLs) {
    72                 LineSegment myLs = null;
    73                 for (LineSegment ls : ds.lineSegments) {
    74                         if (match(otherLs, ls)) {
    75                                 myLs = ls;
     83        public void visit(Segment other) {
     84                if (mergeAfterId(mergedSegments, ds.segments, other))
     85                        return;
     86
     87                Segment my = null;
     88                for (Segment ls : ds.segments) {
     89                        if (match(other, ls)) {
     90                                my = ls;
    7691                                break;
    7792                        }
    7893                }
    79                 if (myLs == null)
    80                         ds.lineSegments.add(otherLs);
    81                 else if (myLs.incomplete && !otherLs.incomplete) {
    82                         mergedLineSegments.put(otherLs, myLs);
    83                         myLs.cloneFrom(otherLs);
    84                 } else if (!otherLs.incomplete) {
    85                         mergedLineSegments.put(otherLs, myLs);
    86                         mergeCommon(myLs, otherLs);
    87                         if (myLs.modified && !otherLs.modified)
     94                if (my == null)
     95                        ds.segments.add(other);
     96                else if (my.incomplete && !other.incomplete) {
     97                        mergedSegments.put(other, my);
     98                        my.cloneFrom(other);
     99                } else if (!other.incomplete) {
     100                        mergedSegments.put(other, my);
     101                        mergeCommon(my, other);
     102                        if (my.modified && !other.modified)
    88103                                return;
    89                         if (!match(myLs.from, otherLs.from)) {
    90                                 myLs.from = otherLs.from;
    91                                 myLs.modified = otherLs.modified;
    92                         }
    93                         if (!match(myLs.to, otherLs.to)) {
    94                                 myLs.to = otherLs.to;
    95                                 myLs.modified = otherLs.modified;
    96                         }
    97                 }
    98         }
    99 
    100         /**
    101          * Merge the way if id matches or if all line segments matches and the
     104                        if (!match(my.from, other.from)) {
     105                                my.from = other.from;
     106                                my.modified = other.modified;
     107                        }
     108                        if (!match(my.to, other.to)) {
     109                                my.to = other.to;
     110                                my.modified = other.modified;
     111                        }
     112                }
     113        }
     114
     115        /**
     116         * Merge the way if id matches or if all segments matches and the
    102117         * id is zero of either way.
    103118         */
    104         public void visit(Way otherWay) {
    105                 Way myWay = null;
     119        public void visit(Way other) {
     120                if (mergeAfterId(null, ds.ways, other))
     121                        return;
     122
     123                Way my = null;
    106124                for (Way t : ds.ways) {
    107                         if (match(otherWay, t)) {
    108                                 myWay = t;
     125                        if (match(other, t)) {
     126                                my = t;
    109127                                break;
    110128                        }
    111129                }
    112                 if (myWay == null)
    113                         ds.ways.add(otherWay);
     130                if (my == null)
     131                        ds.ways.add(other);
    114132                else {
    115                         mergeCommon(myWay, otherWay);
    116                         if (myWay.modified && !otherWay.modified)
     133                        mergeCommon(my, other);
     134                        if (my.modified && !other.modified)
    117135                                return;
    118136                        boolean same = true;
    119                         Iterator<LineSegment> it = otherWay.segments.iterator();
    120                         for (LineSegment ls : myWay.segments) {
     137                        Iterator<Segment> it = other.segments.iterator();
     138                        for (Segment ls : my.segments) {
    121139                                if (!match(ls, it.next()))
    122140                                        same = false;
    123141                        }
    124142                        if (!same) {
    125                                 myWay.segments.clear();
    126                                 myWay.segments.addAll(otherWay.segments);
    127                                 myWay.modified = otherWay.modified;
     143                                my.segments.clear();
     144                                my.segments.addAll(other.segments);
     145                                my.modified = other.modified;
    128146                        }
    129147                }
     
    135153         */
    136154        public void fixReferences() {
    137                 for (LineSegment ls : ds.lineSegments) {
    138                         if (mergedNodes.containsKey(ls.from))
    139                                 ls.from = mergedNodes.get(ls.from);
    140                         if (mergedNodes.containsKey(ls.to))
    141                                 ls.to = mergedNodes.get(ls.to);
    142                 }
    143                 for (Way t : ds.ways) {
    144                         boolean replacedSomething = false;
    145                         LinkedList<LineSegment> newSegments = new LinkedList<LineSegment>();
    146                         for (LineSegment ls : t.segments) {
    147                                 LineSegment otherLs = mergedLineSegments.get(ls);
    148                                 newSegments.add(otherLs == null ? ls : otherLs);
    149                                 if (otherLs != null)
    150                                         replacedSomething = true;
    151                         }
    152                         if (replacedSomething) {
    153                                 t.segments.clear();
    154                                 t.segments.addAll(newSegments);
    155                         }
    156                         for (LineSegment ls : t.segments) {
    157                                 if (mergedNodes.containsKey(ls.from))
    158                                         ls.from = mergedNodes.get(ls.from);
    159                                 if (mergedNodes.containsKey(ls.to))
    160                                         ls.to = mergedNodes.get(ls.to);
    161                         }
    162                 }
    163         }
    164        
     155                for (Segment s : ds.segments)
     156                        fixSegment(s);
     157                for (OsmPrimitive osm : conflicts.values())
     158                        if (osm instanceof Segment)
     159                                fixSegment((Segment)osm);
     160                for (Way w : ds.ways)
     161                        fixWay(w);
     162                for (OsmPrimitive osm : conflicts.values())
     163                        if (osm instanceof Way)
     164                                fixWay((Way)osm);
     165        }
     166
     167        private void fixWay(Way t) {
     168            boolean replacedSomething = false;
     169            LinkedList<Segment> newSegments = new LinkedList<Segment>();
     170            for (Segment ls : t.segments) {
     171                Segment otherLs = mergedSegments.get(ls);
     172                newSegments.add(otherLs == null ? ls : otherLs);
     173                if (otherLs != null)
     174                        replacedSomething = true;
     175            }
     176            if (replacedSomething) {
     177                t.segments.clear();
     178                t.segments.addAll(newSegments);
     179            }
     180            for (Segment ls : t.segments) {
     181                fixSegment(ls);
     182            }
     183    }
     184
     185        private void fixSegment(Segment ls) {
     186            if (mergedNodes.containsKey(ls.from))
     187                ls.from = mergedNodes.get(ls.from);
     188            if (mergedNodes.containsKey(ls.to))
     189                ls.to = mergedNodes.get(ls.to);
     190    }
     191
    165192        /**
    166193         * @return Whether the nodes matches (in sense of "be mergable").
     
    171198                return n1.id == n2.id;
    172199        }
    173        
    174         /**
    175          * @return Whether the line segments matches (in sense of "be mergable").
    176          */
    177         private boolean match(LineSegment ls1, LineSegment ls2) {
     200
     201        /**
     202         * @return Whether the segments matches (in sense of "be mergable").
     203         */
     204        private boolean match(Segment ls1, Segment ls2) {
    178205                if (ls1.id == ls2.id)
    179206                        return true;
     
    190217                        if (t1.segments.size() != t2.segments.size())
    191218                                return false;
    192                         Iterator<LineSegment> it = t1.segments.iterator();
    193                         for (LineSegment ls : t2.segments)
     219                        Iterator<Segment> it = t1.segments.iterator();
     220                        for (Segment ls : t2.segments)
    194221                                if (!match(ls, it.next()))
    195222                                        return false;
     
    201228        /**
    202229         * Merge the common parts of an osm primitive.
    203          * @param myOsm The object, the information gets merged into
    204          * @param otherOsm The object, the information gets merged from
    205          */
    206         private void mergeCommon(OsmPrimitive myOsm, OsmPrimitive otherOsm) {
    207                 if (otherOsm.isDeleted())
    208                         myOsm.setDeleted(true);
    209                 if (!myOsm.modified || otherOsm.modified) {
    210                         if (myOsm.id == 0 && otherOsm.id != 0)
    211                                 myOsm.id = otherOsm.id; // means not ncessary the object is now modified
    212                         else if (myOsm.id != 0 && otherOsm.id != 0 && otherOsm.modified)
    213                                 myOsm.modified = true;
    214                 }
    215                 if (myOsm.modifiedProperties && !otherOsm.modifiedProperties)
    216                         return;
    217                 if (otherOsm.keys == null)
    218                         return;
    219                 if (myOsm.keys != null && myOsm.keys.entrySet().containsAll(otherOsm.keys.entrySet()))
    220                         return;
    221                 if (myOsm.keys == null)
    222                         myOsm.keys = otherOsm.keys;
     230         * @param my The object, the information gets merged into
     231         * @param other The object, the information gets merged from
     232         */
     233        private void mergeCommon(OsmPrimitive my, OsmPrimitive other) {
     234                if (other.deleted)
     235                        my.delete(true);
     236                if (my.id == 0 || !my.modified || other.modified) {
     237                        if (my.id == 0 && other.id != 0) {
     238                                my.id = other.id;
     239                                my.modified = other.modified; // match a new node
     240                        } else if (my.id != 0 && other.id != 0 && other.modified)
     241                                my.modified = true;
     242                }
     243                if (other.keys == null)
     244                        return;
     245                if (my.keySet().containsAll(other.keys.entrySet()))
     246                        return;
     247                if (my.keys == null)
     248                        my.keys = other.keys;
    223249                else
    224                         myOsm.keys.putAll(otherOsm.keys);
    225                 myOsm.modifiedProperties = true;
     250                        my.keys.putAll(other.keys);
     251                my.modified = true;
     252        }
     253
     254        private <P extends OsmPrimitive> boolean mergeAfterId(Map<P,P> merged, Collection<P> primitives, P other) {
     255                for (P my : primitives) {
     256                        if (my.realEqual(other))
     257                                return true; // no merge needed.
     258                        if (my.id == other.id) {
     259                                Date d1 = my.timestamp == null ? new Date(0) : my.timestamp;
     260                                Date d2 = other.timestamp == null ? new Date(0) : other.timestamp;
     261                                if (my.modified && other.modified) {
     262                                        conflicts.put(my, other);
     263                                        if (merged != null)
     264                                                merged.put(other, my);
     265                                } else if (!my.modified && !other.modified) {
     266                                        if (d1.before(d2)) {
     267                                                my.cloneFrom(other);
     268                                                if (merged != null)
     269                                                        merged.put(other, my);
     270                                        }
     271                                } else if (other.modified) {
     272                                        if (d1.after(d2)) {
     273                                                conflicts.put(my, other);
     274                                                if (merged != null)
     275                                                        merged.put(other, my);
     276                                        } else {
     277                                                my.cloneFrom(other);
     278                                                if (merged != null)
     279                                                        merged.put(other, my);
     280                                        }
     281                                } else if (my.modified) {
     282                                        if (d2.after(d1)) {
     283                                                conflicts.put(my, other);
     284                                                if (merged != null)
     285                                                        merged.put(other, my);
     286                                        }
     287                                }
     288                                return true;
     289                        }
     290                }
     291                return false;
    226292        }
    227293}
  • src/org/openstreetmap/josm/data/osm/visitor/SelectionComponentVisitor.java

    r79 r86  
    77import javax.swing.Icon;
    88
    9 import org.openstreetmap.josm.data.osm.LineSegment;
     9import org.openstreetmap.josm.data.osm.Segment;
    1010import org.openstreetmap.josm.data.osm.Node;
    1111import org.openstreetmap.josm.data.osm.Way;
     
    3030       
    3131        /**
    32          * If the line segment has a key named "name", its value is displayed.
     32         * If the segment has a key named "name", its value is displayed.
    3333         * Otherwise, if it has "id", this is used. If none of these available,
    3434         * "(x1,y1) -> (x2,y2)" is displayed with the nodes coordinates.
    3535         */
    36         public void visit(LineSegment ls) {
     36        public void visit(Segment ls) {
    3737                name = ls.get("name");
    3838                if (name == null) {
     
    6565                        AllNodesVisitor.getAllNodes(w.segments);
    6666                        Set<Node> nodes = new HashSet<Node>();
    67                         for (LineSegment ls : w.segments) {
     67                        for (Segment ls : w.segments) {
    6868                                if (!ls.incomplete) {
    6969                                        nodes.add(ls.from);
  • src/org/openstreetmap/josm/data/osm/visitor/SimplePaintVisitor.java

    r75 r86  
    66
    77import org.openstreetmap.josm.Main;
    8 import org.openstreetmap.josm.data.osm.LineSegment;
     8import org.openstreetmap.josm.data.osm.Segment;
    99import org.openstreetmap.josm.data.osm.Node;
    1010import org.openstreetmap.josm.data.osm.Way;
     
    3232         */
    3333        private final NavigatableComponent nc;
    34        
     34
    3535        /**
    3636         * Construct the painter visitor.
     
    4242                this.nc = mv;
    4343        }
    44        
     44
    4545        /**
    4646         * Draw a small rectangle.
     
    5050         */
    5151        public void visit(Node n) {
    52                 drawNode(n, n.isSelected() ? getPreferencesColor("selected", Color.WHITE)
     52                drawNode(n, n.selected ? getPreferencesColor("selected", Color.WHITE)
    5353                                : getPreferencesColor("node", Color.RED));
    5454        }
     
    5858         * White if selected (as always) or green otherwise.
    5959         */
    60         public void visit(LineSegment ls) {
    61                 drawLineSegment(ls, getPreferencesColor("segment", darkgreen));
     60        public void visit(Segment ls) {
     61                drawSegment(ls, getPreferencesColor("segment", darkgreen));
    6262        }
    6363
    6464        /**
    65          * Draw a darkblue line for all line segments.
    66          * @param t The way to draw.
     65         * Draw a darkblue line for all segments.
     66         * @param w The way to draw.
    6767         */
    68         public void visit(Way t) {
     68        public void visit(Way w) {
    6969                // only to overwrite with blue
    7070                Color wayColor = getPreferencesColor("way", darkblue);
    71                 for (LineSegment ls : t.segments) {
     71                for (Segment ls : w.segments) {
    7272                        if (ls.incomplete) {
    7373                                wayColor = getPreferencesColor("incomplete way", darkerblue);
     
    7575                        }
    7676                }
    77                 for (LineSegment ls : t.segments)
    78                         if (!ls.isSelected()) // selected already in good color
    79                                 drawLineSegment(ls, t.isSelected() ? getPreferencesColor("selected", Color.WHITE) : wayColor);
     77                for (Segment ls : w.segments)
     78                        if (!ls.selected) // selected already in good color
     79                                drawSegment(ls, w.selected ? getPreferencesColor("selected", Color.WHITE) : wayColor);
    8080        }
    8181
     
    9595         * Draw a line with the given color.
    9696         */
    97         private void drawLineSegment(LineSegment ls, Color col) {
     97        private void drawSegment(Segment ls, Color col) {
    9898                if (ls.incomplete)
    9999                        return;
    100                 if (ls.isSelected())
     100                if (ls.selected)
    101101                        col = getPreferencesColor("selected", Color.WHITE);
    102102                g.setColor(col);
     
    105105                g.drawLine(p1.x, p1.y, p2.x, p2.y);
    106106        }
    107        
    108         private Color getPreferencesColor(String colName, Color def) {
     107
     108        public static Color getPreferencesColor(String colName, Color def) {
    109109                String colStr = Main.pref.get("color."+colName);
    110110                if (colStr.equals(""))
  • src/org/openstreetmap/josm/data/osm/visitor/Visitor.java

    r66 r86  
    11package org.openstreetmap.josm.data.osm.visitor;
    22
    3 import org.openstreetmap.josm.data.osm.LineSegment;
     3import org.openstreetmap.josm.data.osm.Segment;
    44import org.openstreetmap.josm.data.osm.Node;
    55import org.openstreetmap.josm.data.osm.Way;
     
    1313public interface Visitor {
    1414        void visit(Node n);
    15         void visit(LineSegment ls);
     15        void visit(Segment s);
    1616        void visit(Way w);
    1717}
  • src/org/openstreetmap/josm/data/projection/Epsg4326.java

    r79 r86  
    1919        }
    2020
    21         @Override
    22         public String toString() {
     21        @Override public String toString() {
    2322                return "EPSG:4326";
    2423        }
  • src/org/openstreetmap/josm/data/projection/Mercator.java

    r79 r86  
    2727        }
    2828
    29         @Override
    30         public String toString() {
     29        @Override public String toString() {
    3130                return "Mercator";
    3231        }
  • src/org/openstreetmap/josm/gui/BookmarkList.java

    r73 r86  
    4747                setVisibleRowCount(7);
    4848                setCellRenderer(new DefaultListCellRenderer(){
    49                         @Override
    50                         public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
     49                        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    5150                                Component c = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
    5251                                if (c instanceof JLabel) {
  • src/org/openstreetmap/josm/gui/MapFrame.java

    r79 r86  
    1515
    1616import org.openstreetmap.josm.actions.AutoScaleAction;
    17 import org.openstreetmap.josm.actions.mapmode.AddLineSegmentAction;
     17import org.openstreetmap.josm.actions.mapmode.AddSegmentAction;
    1818import org.openstreetmap.josm.actions.mapmode.AddNodeAction;
    1919import org.openstreetmap.josm.actions.mapmode.AddWayAction;
     
    2323import org.openstreetmap.josm.actions.mapmode.SelectionAction;
    2424import org.openstreetmap.josm.actions.mapmode.ZoomAction;
     25import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
    2526import org.openstreetmap.josm.gui.dialogs.LayerList;
    2627import org.openstreetmap.josm.gui.dialogs.PropertiesDialog;
     
    5354         */
    5455        public MapStatus statusLine;
     56       
     57        public ConflictDialog conflictDialog;
     58       
    5559        /**
    5660         * Construct a map with a given DataSet. The set cannot be replaced after
     
    7377                toolBarActions.add(new IconToggleButton(new MoveAction(this)));
    7478                toolBarActions.add(new IconToggleButton(new AddNodeAction(this)));
    75                 toolBarActions.add(new IconToggleButton(new AddLineSegmentAction(this)));
     79                toolBarActions.add(new IconToggleButton(new AddSegmentAction(this)));
    7680                toolBarActions.add(new IconToggleButton(new AddWayAction(this, selectionAction)));
    7781                toolBarActions.add(new IconToggleButton(new DeleteAction(this)));
     
    104108                addIconToggle(toggleDialogs, new PropertiesDialog(this));
    105109                addIconToggle(toggleDialogs, new SelectionListDialog(this));
     110                addIconToggle(toggleDialogs, conflictDialog = new ConflictDialog());
    106111
    107112                // status line below the map
     
    119124         * Fires an property changed event "visible".
    120125         */
    121         @Override
    122         public void setVisible(boolean aFlag) {
     126        @Override public void setVisible(boolean aFlag) {
    123127                boolean old = isVisible();
    124128                super.setVisible(aFlag);
  • src/org/openstreetmap/josm/gui/MapMover.java

    r71 r86  
    6464         * Start the movement, if it was the 3rd button (right button).
    6565         */
    66         @Override
    67         public void mousePressed(MouseEvent e) {
     66        @Override public void mousePressed(MouseEvent e) {
    6867                int offMask = MouseEvent.BUTTON1_DOWN_MASK | MouseEvent.BUTTON2_DOWN_MASK;
    6968                if (e.getButton() == MouseEvent.BUTTON3 && (e.getModifiersEx() & offMask) == 0)
     
    7473         * Change the cursor back to it's pre-move cursor.
    7574         */
    76         @Override
    77         public void mouseReleased(MouseEvent e) {
     75        @Override public void mouseReleased(MouseEvent e) {
    7876                if (e.getButton() == MouseEvent.BUTTON3)
    7977                        endMovement();
  • src/org/openstreetmap/josm/gui/MapStatus.java

    r71 r86  
    1414import java.beans.PropertyChangeEvent;
    1515import java.beans.PropertyChangeListener;
     16import java.util.Arrays;
    1617import java.util.Collection;
    1718import java.util.ConcurrentModificationException;
     
    135136                                                        osm.visit(visitor);
    136137                                                        final StringBuilder text = new StringBuilder();
    137                                                         if (osm.id == 0 || osm.modified || osm.modifiedProperties)
     138                                                        if (osm.id == 0 || osm.modified)
    138139                                                                visitor.name = "<i><b>"+visitor.name+"*</b></i>";
    139140                                                        text.append(visitor.name);
     
    147148                                                        l.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    148149                                                        l.addMouseListener(new MouseAdapter(){
    149                                                                 @Override
    150                                                                 public void mouseEntered(MouseEvent e) {
     150                                                                @Override public void mouseEntered(MouseEvent e) {
    151151                                                                        l.setText("<html><u color='blue'>"+text.toString()+"</u></html>");
    152152                                                                }
    153                                                                 @Override
    154                                                                 public void mouseExited(MouseEvent e) {
     153                                                                @Override public void mouseExited(MouseEvent e) {
    155154                                                                        l.setText("<html>"+text.toString()+"</html>");
    156155                                                                }
    157                                                                 @Override
    158                                                                 public void mouseClicked(MouseEvent e) {
    159                                                                         Main.main.ds.clearSelection();
    160                                                                         osm.setSelected(true);
     156                                                                @Override public void mouseClicked(MouseEvent e) {
     157                                                                        Main.ds.setSelected(Arrays.asList(new OsmPrimitive[]{osm}));
    161158                                                                        mv.repaint();
    162159                                                                }
  • src/org/openstreetmap/josm/gui/MapView.java

    r79 r86  
    1313import org.openstreetmap.josm.Main;
    1414import org.openstreetmap.josm.data.Bounds;
     15import org.openstreetmap.josm.data.SelectionChangedListener;
    1516import org.openstreetmap.josm.data.coor.EastNorth;
    1617import org.openstreetmap.josm.data.coor.LatLon;
    1718import org.openstreetmap.josm.data.osm.DataSet;
     19import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1820import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    1921import org.openstreetmap.josm.data.projection.Projection;
     
    7678        public MapView(Layer layer) {
    7779                addComponentListener(new ComponentAdapter(){
    78                         @Override
    79                         public void componentResized(ComponentEvent e) {
     80                        @Override public void componentResized(ComponentEvent e) {
    8081                                recalculateCenterScale();
    8182                        }
     
    8384                new MapMover(this);
    8485                addLayer(layer);
     86               
     87                // listend to selection changes to redraw the map
     88                Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
     89                        public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     90                                repaint();
     91            }
     92                });
    8593        }
    8694
     
    155163         * Draw the component.
    156164         */
    157         @Override
    158         public void paint(Graphics g) {
     165        @Override public void paint(Graphics g) {
    159166                g.setColor(Color.BLACK);
    160167                g.fillRect(0, 0, getWidth(), getHeight());
     
    218225                        double oldScale = this.scale;
    219226                       
    220                         if (v.min == null || v.max == null) {
     227                        if (v.min == null || v.max == null || v.min.equals(v.max)) {
    221228                                // no bounds means whole world
    222229                                center = getProjection().latlon2eastNorth(new LatLon(0,0));
     
    225232                                double scaleY = world.north()*2/h;
    226233                                scale = Math.max(scaleX, scaleY); // minimum scale to see all of the screen
    227                                
    228234                        } else {
    229235                                center = new EastNorth(v.min.east()/2+v.max.east()/2, v.min.north()/2+v.max.north()/2);
     
    277283                activeLayer = layer;
    278284                if (layer instanceof OsmDataLayer)
    279                         Main.main.ds = ((OsmDataLayer)layer).data;
     285                        Main.ds = ((OsmDataLayer)layer).data;
    280286                if (old != layer) {
    281287                        for (LayerChangeListener l : listeners)
     
    306312         * feature.
    307313         */
    308         @Override
    309         public void zoomTo(EastNorth newCenter, double scale) {
     314        @Override public void zoomTo(EastNorth newCenter, double scale) {
    310315                boolean oldAutoScale = autoScale;
    311316                EastNorth oldCenter = center;
  • src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r73 r86  
    1010import org.openstreetmap.josm.data.coor.LatLon;
    1111import org.openstreetmap.josm.data.coor.EastNorth;
    12 import org.openstreetmap.josm.data.osm.LineSegment;
     12import org.openstreetmap.josm.data.osm.Segment;
    1313import org.openstreetmap.josm.data.osm.Node;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    109109         * nearest node is returned.
    110110         *
    111          * If no node is found, search for pending line segments.
    112          *
    113          * If no such line segment is found, and a non-pending line segment is
     111         * If no node is found, search for pending segments.
     112         *
     113         * If no such segment is found, and a non-pending segment is
    114114         * within 10 pixel to p, this segment is returned, except when
    115115         * <code>wholeWay</code> is <code>true</code>, in which case the
    116116         * corresponding Way is returned.
    117117         *
    118          * If no line segment is found and the point is within an area, return that
     118         * If no segment is found and the point is within an area, return that
    119119         * area.
    120120         *
     
    122122         *
    123123         * @param p                              The point on screen.
    124          * @param segmentInsteadWay Whether the line segment (true) or only the whole
     124         * @param segmentInsteadWay Whether the segment (true) or only the whole
    125125         *                                               way should be returned.
    126126         * @return      The primitive, that is nearest to the point p.
     
    131131       
    132132                // nodes
    133                 for (Node n : Main.main.ds.nodes) {
    134                         if (n.isDeleted())
     133                for (Node n : Main.ds.nodes) {
     134                        if (n.deleted)
    135135                                continue;
    136136                        Point sp = getPoint(n.eastNorth);
     
    147147                minDistanceSq = Double.MAX_VALUE;
    148148                if (!segmentInsteadWay) {
    149                         for (Way w : Main.main.ds.ways) {
    150                                 if (w.isDeleted())
     149                        for (Way w : Main.ds.ways) {
     150                                if (w.deleted)
    151151                                        continue;
    152                                 for (LineSegment ls : w.segments) {
    153                                         if (ls.isDeleted() || ls.incomplete)
     152                                for (Segment ls : w.segments) {
     153                                        if (ls.deleted || ls.incomplete)
    154154                                                continue;
    155155                                        Point A = getPoint(ls.from.eastNorth);
     
    170170               
    171171                minDistanceSq = Double.MAX_VALUE;
    172                 // line segments
    173                 for (LineSegment ls : Main.main.ds.lineSegments) {
    174                         if (ls.isDeleted() || ls.incomplete)
     172                // segments
     173                for (Segment ls : Main.ds.segments) {
     174                        if (ls.deleted || ls.incomplete)
    175175                                continue;
    176176                        Point A = getPoint(ls.from.eastNorth);
     
    194194         * determined.
    195195         *
    196          * If its a node, return all line segments and
     196         * If its a node, return all segments and
    197197         * streets the node is part of, as well as all nodes
    198          * (with their line segments and ways) with the same
     198         * (with their segments and ways) with the same
    199199         * location.
    200200         *
    201          * If its a line segment, return all ways this segment
    202          * belongs to as well as all line segments that are between
     201         * If its a segment, return all ways this segment
     202         * belongs to as well as all segments that are between
    203203         * the same nodes (in both direction) with all their ways.
    204204         *
     
    215215                if (osm instanceof Node) {
    216216                        Node node = (Node)osm;
    217                         for (Node n : Main.main.ds.nodes)
    218                                 if (!n.isDeleted() && n.coor.equals(node.coor))
     217                        for (Node n : Main.ds.nodes)
     218                                if (!n.deleted && n.coor.equals(node.coor))
    219219                                        c.add(n);
    220                         for (LineSegment ls : Main.main.ds.lineSegments)
    221                                 // line segments never match nodes, so they are skipped by contains
    222                                 if (!ls.isDeleted() && !ls.incomplete && (c.contains(ls.from) || c.contains(ls.to)))
     220                        for (Segment ls : Main.ds.segments)
     221                                // segments never match nodes, so they are skipped by contains
     222                                if (!ls.deleted && !ls.incomplete && (c.contains(ls.from) || c.contains(ls.to)))
    223223                                        c.add(ls);
    224224                }
    225                 if (osm instanceof LineSegment) {
    226                         LineSegment line = (LineSegment)osm;
    227                         for (LineSegment ls : Main.main.ds.lineSegments)
    228                                 if (!ls.isDeleted() && ls.equalPlace(line))
     225                if (osm instanceof Segment) {
     226                        Segment line = (Segment)osm;
     227                        for (Segment ls : Main.ds.segments)
     228                                if (!ls.deleted && ls.equalPlace(line))
    229229                                        c.add(ls);
    230230                }
    231                 if (osm instanceof Node || osm instanceof LineSegment) {
    232                         for (Way t : Main.main.ds.ways) {
    233                                 if (t.isDeleted())
     231                if (osm instanceof Node || osm instanceof Segment) {
     232                        for (Way t : Main.ds.ways) {
     233                                if (t.deleted)
    234234                                        continue;
    235                                 for (LineSegment ls : t.segments) {
    236                                         if (!ls.isDeleted() && !ls.incomplete && c.contains(ls)) {
     235                                for (Segment ls : t.segments) {
     236                                        if (!ls.deleted && !ls.incomplete && c.contains(ls)) {
    237237                                                c.add(t);
    238238                                                break;
  • src/org/openstreetmap/josm/gui/OsmPrimitivRenderer.java

    r33 r86  
    1818        private SelectionComponentVisitor visitor = new SelectionComponentVisitor();
    1919
    20         @Override
    21         public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
     20        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    2221                Component c = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
    2322                if (c instanceof JLabel && value != null) {
  • src/org/openstreetmap/josm/gui/PreferenceDialog.java

    r85 r86  
    153153         * The checkbox stating whether raw gps lines should be forced.
    154154         */
    155         private JCheckBox forceRawGpsLines = new JCheckBox("Force lines if no line segments imported.");
     155        private JCheckBox forceRawGpsLines = new JCheckBox("Force lines if no segments imported.");
    156156
    157157        private JTable colors;
  • src/org/openstreetmap/josm/gui/SelectionManager.java

    r71 r86  
    1616
    1717import org.openstreetmap.josm.Main;
    18 import org.openstreetmap.josm.data.osm.LineSegment;
     18import org.openstreetmap.josm.data.osm.Segment;
    1919import org.openstreetmap.josm.data.osm.Node;
    2020import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    257257         * @param alt Whether the alt key was pressed, which means select all objects
    258258         *              that are touched, instead those which are completly covered. Also
    259          *              select whole ways instead of line segments.
     259         *              select whole ways instead of segments.
    260260         */
    261261        public Collection<OsmPrimitive> getObjectsInRectangle(Rectangle r, boolean alt) {
     
    272272                } else {
    273273                        // nodes
    274                         for (Node n : Main.main.ds.nodes) {
     274                        for (Node n : Main.ds.nodes) {
    275275                                if (r.contains(nc.getPoint(n.eastNorth)))
    276276                                        selection.add(n);
    277277                        }
    278278                       
    279                         // pending line segments
    280                         for (LineSegment ls : Main.main.ds.lineSegments)
    281                                 if (rectangleContainLineSegment(r, alt, ls))
     279                        // pending segments
     280                        for (Segment ls : Main.ds.segments)
     281                                if (rectangleContainSegment(r, alt, ls))
    282282                                        selection.add(ls);
    283283
    284284                        // ways
    285                         for (Way t : Main.main.ds.ways) {
     285                        for (Way t : Main.ds.ways) {
    286286                                boolean wholeWaySelected = !t.segments.isEmpty();
    287                                 for (LineSegment ls : t.segments)
    288                                         if (rectangleContainLineSegment(r, alt, ls))
     287                                for (Segment ls : t.segments)
     288                                        if (rectangleContainSegment(r, alt, ls))
    289289                                                selection.add(ls);
    290290                                        else
     
    300300
    301301        /**
    302          * Decide whether the line segment is in the rectangle Return
     302         * Decide whether the segment is in the rectangle Return
    303303         * <code>true</code>, if it is in or false if not.
    304304         *
    305          * @param r                     The rectangle, in which the line segment has to be.
     305         * @param r                     The rectangle, in which the segment has to be.
    306306         * @param alt           Whether user pressed the Alt key
    307          * @param ls            The line segment.
    308          * @return <code>true</code>, if the LineSegment was added to the selection.
    309          */
    310         private boolean rectangleContainLineSegment(Rectangle r, boolean alt, LineSegment ls) {
     307         * @param ls            The segment.
     308         * @return <code>true</code>, if the Segment was added to the selection.
     309         */
     310        private boolean rectangleContainSegment(Rectangle r, boolean alt, Segment ls) {
    311311                if (ls.incomplete)
    312312                        return false;
  • src/org/openstreetmap/josm/gui/ShowModifiers.java

    r46 r86  
    131131        }
    132132
    133         @Override
    134         public void paint(Graphics g) {
     133        @Override public void paint(Graphics g) {
    135134                super.paint(g);
    136135                paintMouse(g);
  • src/org/openstreetmap/josm/gui/WorldChooser.java

    r79 r86  
    7272                                                p.east()*360/world.getIconWidth() - 180);
    7373                        }
    74                         @Override
    75                         public String toString() {
     74                        @Override public String toString() {
    7675                                return "WorldChooser";
    7776                        }
     
    8786         * Set the scale as well as the preferred size.
    8887         */
    89         @Override
    90         public void setPreferredSize(Dimension preferredSize) {
     88        @Override public void setPreferredSize(Dimension preferredSize) {
    9189                super.setPreferredSize(preferredSize);
    9290                scale = world.getIconWidth()/preferredSize.getWidth();
     
    9896         * Draw the current selected region.
    9997         */
    100         @Override
    101         public void paint(Graphics g) {
     98        @Override public void paint(Graphics g) {
    10299                EastNorth tl = getEastNorth(0,0);
    103100                EastNorth br = getEastNorth(getWidth(),getHeight());
     
    122119
    123120
    124         @Override
    125         public void zoomTo(EastNorth newCenter, double scale) {
     121        @Override public void zoomTo(EastNorth newCenter, double scale) {
    126122                if (getWidth() != 0 && scale > scaleMax) {
    127123                        scale = scaleMax;
     
    158154                // messages are dispatched and so text fields are updated.
    159155                KeyListener listener = new KeyAdapter(){
    160                         @Override
    161                         public void keyTyped(KeyEvent e) {
     156                        @Override public void keyTyped(KeyEvent e) {
    162157                                SwingUtilities.invokeLater(new Runnable(){
    163158                                        public void run() {
     
    216211         * Always use our image projection mode.
    217212         */
    218         @Override
    219         protected Projection getProjection() {
     213        @Override protected Projection getProjection() {
    220214                return projection;
    221215        }
  • src/org/openstreetmap/josm/gui/dialogs/LayerList.java

    r79 r86  
    5959                if (layers.getModel().getSize() == 1) {
    6060                        Main.main.setMapFrame(null);
    61                         Main.main.ds = new DataSet();
     61                        Main.ds = new DataSet();
    6262                } else {
    6363                    int sel = layers.getSelectedIndex();
     
    133133                layers.setBackground(UIManager.getColor("Button.background"));
    134134                layers.setCellRenderer(new DefaultListCellRenderer(){
    135                         @Override
    136                         public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
     135                        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    137136                                Layer layer = (Layer)value;
    138137                                JLabel label = (JLabel)super.getListCellRendererComponent(list,
  • src/org/openstreetmap/josm/gui/dialogs/LayerListPopup.java

    r79 r86  
    11package org.openstreetmap.josm.gui.dialogs;
    22
    3 import java.awt.Color;
    43import java.awt.event.ActionEvent;
    5 import java.awt.event.ActionListener;
    64
    7 import javax.swing.JColorChooser;
     5import javax.swing.AbstractAction;
    86import javax.swing.JList;
    9 import javax.swing.JMenuItem;
    107import javax.swing.JOptionPane;
    118import javax.swing.JPopupMenu;
    129
    1310import org.openstreetmap.josm.Main;
    14 import org.openstreetmap.josm.actions.GpxExportAction;
    15 import org.openstreetmap.josm.actions.SaveAction;
    1611import org.openstreetmap.josm.gui.layer.Layer;
    17 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    18 import org.openstreetmap.josm.gui.layer.RawGpsDataLayer;
    19 import org.openstreetmap.josm.gui.layer.WmsServerLayer;
    20 import org.openstreetmap.josm.tools.ColorHelper;
    2112import org.openstreetmap.josm.tools.ImageProvider;
    2213
     
    2617public class LayerListPopup extends JPopupMenu {
    2718
     19        public final static class InfoAction extends AbstractAction {
     20            private final Layer layer;
     21            public InfoAction(Layer layer) {
     22                super("Info", ImageProvider.get("info"));
     23                    this.layer = layer;
     24            }
     25            public void actionPerformed(ActionEvent e) {
     26                JOptionPane.showMessageDialog(Main.main, layer.getInfoComponent());
     27            }
     28    }
     29
    2830        public LayerListPopup(final JList layers, final Layer layer) {
    29         add(new LayerList.ShowHideLayerAction(layers, layer));
    30         add(new LayerList.DeleteLayerAction(layers, layer));
    31         addSeparator();
    32        
    33                 if (layer instanceof OsmDataLayer)
    34                         add(new JMenuItem(new SaveAction()));
     31                add(new LayerList.ShowHideLayerAction(layers, layer));
     32                add(new LayerList.DeleteLayerAction(layers, layer));
     33                addSeparator();
    3534
    36         if (!(layer instanceof WmsServerLayer))
    37             add(new JMenuItem(new GpxExportAction(layer)));
    38 
    39                 if (layer instanceof RawGpsDataLayer) {
    40                         JMenuItem color = new JMenuItem("Customize Color", ImageProvider.get("colorchooser"));
    41                         color.addActionListener(new ActionListener(){
    42                                 public void actionPerformed(ActionEvent e) {
    43                                         String col = Main.pref.get("color.layer "+layer.name, Main.pref.get("color.gps point", ColorHelper.color2html(Color.gray)));
    44                                         JColorChooser c = new JColorChooser(ColorHelper.html2color(col));
    45                                         Object[] options = new Object[]{"OK", "Cancel", "Default"};
    46                                         int answer = JOptionPane.showOptionDialog(Main.main, c, "Choose a color", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
    47                                         switch (answer) {
    48                                         case 0:
    49                                                 Main.pref.put("color.layer "+layer.name, ColorHelper.color2html(c.getColor()));
    50                                                 break;
    51                                         case 1:
    52                                                 return;
    53                                         case 2:
    54                                                 Main.pref.put("color.layer "+layer.name, null);
    55                                                 break;
    56                                         }
    57                                         Main.main.repaint();
    58                                 }
    59                         });
    60                         add(color);
    61                 }
    62 
    63         if (!(layer instanceof WmsServerLayer))
    64             addSeparator();
    65 
    66                 JMenuItem info = new JMenuItem("Info", ImageProvider.get("info"));
    67                 info.addActionListener(new ActionListener(){
    68                         public void actionPerformed(ActionEvent e) {
    69                                 JOptionPane.showMessageDialog(Main.main, layer.getInfoComponent());
    70                         }
    71                 });
    72                 add(info);
     35                layer.addMenuEntries(this);
    7336        }
    7437}
  • src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r79 r86  
    3636
    3737import org.openstreetmap.josm.Main;
    38 import org.openstreetmap.josm.command.ChangeKeyValueCommand;
     38import org.openstreetmap.josm.command.ChangePropertyCommand;
    3939import org.openstreetmap.josm.data.SelectionChangedListener;
    4040import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    6868         */
    6969        public class DblClickWatch extends MouseAdapter {
    70                 @Override
    71                 public void mouseClicked(MouseEvent e) {
     70                @Override public void mouseClicked(MouseEvent e) {
    7271                        if (e.getClickCount() < 2)
    7372                                return;
     
    8786        void edit(int row) {
    8887                String key = data.getValueAt(row, 0).toString();
    89                 Collection<OsmPrimitive> sel = Main.main.ds.getSelected();
     88                Collection<OsmPrimitive> sel = Main.ds.getSelected();
    9089                String msg = "<html>This will change "+sel.size()+" object"+(sel.size()==1?"":"s")+".<br><br>"+
    9190                "Please select a new value for '"+key+"'.<br>(Empty string deletes the key.)";
     
    125124                if (value.equals(""))
    126125                        value = null; // delete the key
    127                 mv.editLayer().add(new ChangeKeyValueCommand(sel, key, value));
     126                mv.editLayer().add(new ChangePropertyCommand(sel, key, value));
    128127
    129128                if (value == null)
     
    138137         */
    139138        void add() {
    140                 Collection<OsmPrimitive> sel = Main.main.ds.getSelected();
     139                Collection<OsmPrimitive> sel = Main.ds.getSelected();
    141140               
    142141                JPanel p = new JPanel(new BorderLayout());
     
    144143                "Please select a key"), BorderLayout.NORTH);
    145144                Vector<String> allKeys = new Vector<String>();
    146                 for (OsmPrimitive osm : Main.main.ds.allNonDeletedPrimitives())
     145                for (OsmPrimitive osm : Main.ds.allNonDeletedPrimitives())
    147146                        allKeys.addAll(osm.keySet());
    148147                for (Iterator<String> it = allKeys.iterator(); it.hasNext();) {
     
    172171                if (value.equals(""))
    173172                        return;
    174                 mv.editLayer().add(new ChangeKeyValueCommand(sel, key, value));
     173                mv.editLayer().add(new ChangePropertyCommand(sel, key, value));
    175174                selectionChanged(sel); // update table
    176175        }
     
    182181        private void delete(int row) {
    183182                String key = data.getValueAt(row, 0).toString();
    184                 Collection<OsmPrimitive> sel = Main.main.ds.getSelected();
    185                 mv.editLayer().add(new ChangeKeyValueCommand(sel, key, null));
     183                Collection<OsmPrimitive> sel = Main.ds.getSelected();
     184                mv.editLayer().add(new ChangePropertyCommand(sel, key, null));
    186185                selectionChanged(sel); // update table
    187186        }
     
    191190         */
    192191        private final DefaultTableModel data = new DefaultTableModel(){
    193                 @Override
    194                 public boolean isCellEditable(int row, int column) {
     192                @Override public boolean isCellEditable(int row, int column) {
    195193                        return false;
    196194                }
    197                 @Override
    198                 public Class<?> getColumnClass(int columnIndex) {
     195                @Override public Class<?> getColumnClass(int columnIndex) {
    199196                        return columnIndex == 1 ? JComboBox.class : String.class;
    200197                }
     
    221218                propertyTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    222219                propertyTable.setDefaultRenderer(JComboBox.class, new DefaultTableCellRenderer(){
    223                         @Override
    224                         public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
     220                        @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
    225221                                Component c = super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
    226222                                if (c instanceof JLabel) {
     
    234230                });
    235231                propertyTable.setDefaultRenderer(String.class, new DefaultTableCellRenderer(){
    236                         @Override
    237                         public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
     232                        @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
    238233                                return super.getTableCellRendererComponent(table, value, isSelected, false, row, column);
    239234                        }
     
    279274        }
    280275
    281         @Override
    282         public void setVisible(boolean b) {
     276        @Override public void setVisible(boolean b) {
    283277                if (b) {
    284                         Main.main.ds.addSelectionChangedListener(this);
    285                         selectionChanged(Main.main.ds.getSelected());
     278                        Main.ds.addSelectionChangedListener(this);
     279                        selectionChanged(Main.ds.getSelected());
    286280                } else {
    287                         Main.main.ds.removeSelectionChangedListener(this);
     281                        Main.ds.removeSelectionChangedListener(this);
    288282                }
    289283                super.setVisible(b);
     
    291285
    292286        public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     287                if (propertyTable == null)
     288                        return; // selection changed may be received in base class constructor before init
    293289                if (propertyTable.getCellEditor() != null)
    294290                        propertyTable.getCellEditor().cancelCellEditing();
  • src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r81 r86  
    1111import java.awt.event.MouseEvent;
    1212import java.util.Collection;
     13import java.util.LinkedList;
    1314
    1415import javax.swing.ButtonGroup;
     
    6162                displaylist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
    6263                displaylist.addMouseListener(new MouseAdapter(){
    63                         @Override
    64                         public void mouseClicked(MouseEvent e) {
     64                        @Override public void mouseClicked(MouseEvent e) {
    6565                                if (e.getClickCount() < 2)
    6666                                        return;
     
    122122                                lastSearch = input.getText();
    123123                                SearchCompiler.Match matcher = SearchCompiler.compile(lastSearch);
    124                                 for (OsmPrimitive osm : Main.main.ds.allNonDeletedPrimitives()) {
    125                                         if (replace.isSelected())
    126                                                 osm.setSelected(matcher.match(osm));
    127                                         else if (add.isSelected() && !osm.isSelected() && matcher.match(osm))
    128                                                 osm.setSelected(true);
    129                                         else if (remove.isSelected() && osm.isSelected() && matcher.match(osm))
    130                                                 osm.setSelected(false);
     124                                Collection<OsmPrimitive> sel = Main.ds.getSelected();
     125                                for (OsmPrimitive osm : Main.ds.allNonDeletedPrimitives()) {
     126                                        if (replace.isSelected()) {
     127                                                if (matcher.match(osm))
     128                                                        sel.add(osm);
     129                                                else
     130                                                        sel.remove(osm);
     131                                        } else if (add.isSelected() && !osm.selected && matcher.match(osm))
     132                                                sel.add(osm);
     133                                        else if (remove.isSelected() && osm.selected && matcher.match(osm))
     134                                                sel.remove(osm);
    131135                                }
    132                                 selectionChanged(Main.main.ds.getSelected());
    133                                 Main.main.getMapFrame().repaint();
     136                                Main.ds.setSelected(sel);
    134137                        }
    135138                });
     
    137140               
    138141                add(buttonPanel, BorderLayout.SOUTH);
    139                 selectionChanged(Main.main.ds.getSelected());
     142                selectionChanged(Main.ds.getSelected());
    140143        }
    141144
    142         @Override
    143         public void setVisible(boolean b) {
     145        @Override public void setVisible(boolean b) {
    144146                if (b) {
    145                         Main.main.ds.addSelectionChangedListener(this);
    146                         selectionChanged(Main.main.ds.getSelected());
     147                        Main.ds.addSelectionChangedListener(this);
     148                        selectionChanged(Main.ds.getSelected());
    147149                } else {
    148                         Main.main.ds.removeSelectionChangedListener(this);
     150                        Main.ds.removeSelectionChangedListener(this);
    149151                }
    150152                super.setVisible(b);
     
    158160         */
    159161        public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     162                if (list == null)
     163                        return; // selection changed may be received in base class constructor before init
    160164                list.removeAllElements();
    161165                list.setSize(newSelection.size());
     
    169173         */
    170174        public void updateMap() {
    171                 Main.main.ds.clearSelection();
     175                Collection<OsmPrimitive> sel = new LinkedList<OsmPrimitive>();
    172176                for (int i = 0; i < list.getSize(); ++i)
    173177                        if (displaylist.isSelectedIndex(i))
    174                                 ((OsmPrimitive)list.get(i)).setSelected(true);
    175                 Main.main.getMapFrame().repaint();
     178                                sel.add((OsmPrimitive)list.get(i));
     179                Main.ds.setSelected(sel);
    176180        }
    177181}
  • src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r81 r86  
    3232         * @param title The title of the dialog.
    3333     * @param prefName Name of the base preference setting string (prefix)
    34      *      with the final . (e.g.: "layerlist.")
    3534         */
    3635        public ToggleDialog(String title, String name, String iconName, String tooltip, String shortCutName, int shortCut, final String prefName) {
     
    4140                                        show = ((AbstractButton)e.getSource()).isSelected();
    4241                                setVisible(show);
    43                 Main.pref.put(prefName+"visible", show);
     42                Main.pref.put(prefName+".visible", show);
    4443                        }
    4544                };
     
    4847                setVisible(false);
    4948                setBorder(BorderFactory.createEtchedBorder());
    50                 if (Main.pref.getBoolean(prefName+"visible")) {
     49                if (Main.pref.getBoolean(prefName+".visible")) {
    5150                    EventQueue.invokeLater(new Runnable(){
    5251                        public void run() {
  • src/org/openstreetmap/josm/gui/layer/Layer.java

    r78 r86  
    44
    55import javax.swing.Icon;
     6import javax.swing.JPopupMenu;
    67
    78import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     
    8081
    8182        abstract public Object getInfoComponent();
     83       
     84        abstract public void addMenuEntries(JPopupMenu menu);
    8285}
  • src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r78 r86  
    1212import javax.swing.Icon;
    1313import javax.swing.JLabel;
     14import javax.swing.JMenuItem;
    1415import javax.swing.JPanel;
     16import javax.swing.JPopupMenu;
    1517
    1618import org.openstreetmap.josm.Main;
     19import org.openstreetmap.josm.actions.GpxExportAction;
     20import org.openstreetmap.josm.actions.SaveAction;
    1721import org.openstreetmap.josm.command.Command;
    1822import org.openstreetmap.josm.data.osm.DataSet;
    19 import org.openstreetmap.josm.data.osm.LineSegment;
     23import org.openstreetmap.josm.data.osm.Segment;
    2024import org.openstreetmap.josm.data.osm.Node;
    2125import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2630import org.openstreetmap.josm.data.osm.visitor.Visitor;
    2731import org.openstreetmap.josm.gui.MapView;
     32import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    2833import org.openstreetmap.josm.tools.GBC;
    2934import org.openstreetmap.josm.tools.ImageProvider;
     
    3742public class OsmDataLayer extends Layer {
    3843
     44        public final static class DataCountVisitor implements Visitor {
     45                public final int[] normal = new int[3];         
     46                public final int[] deleted = new int[3];
     47                public final String[] names = {"node", "segment", "way"};
     48
     49                private void inc(OsmPrimitive osm, int i) {
     50                        normal[i]++;
     51                        if (osm.deleted)
     52                                deleted[i]++;
     53                }
     54
     55                public void visit(Node n) {
     56                        inc(n, 0);
     57                }
     58
     59                public void visit(Segment ls) {
     60                        inc(ls, 1);
     61                }
     62
     63                public void visit(Way w) {
     64                        inc(w, 2);
     65                }
     66        }
     67
    3968        public interface ModifiedChangedListener {
    4069                void modifiedChanged(boolean value, OsmDataLayer source);
    4170        }
    42        
     71
    4372        private static Icon icon;
    4473
     
    75104        LinkedList<ModifiedChangedListener> listener;
    76105
    77        
     106
    78107        /**
    79108         * Construct a OsmDataLayer.
     
    89118         *              updated by a background thread to not disturb the running programm.
    90119         */
    91         @Override
    92         public Icon getIcon() {
     120        @Override public Icon getIcon() {
    93121                if (icon == null)
    94122                        icon = ImageProvider.get("layer", "osmdata");
     
    99127         * Draw all primitives in this layer but do not draw modified ones (they
    100128         * are drawn by the edit layer).
    101          * Draw nodes last to overlap the line segments they belong to.
    102          */
    103         @Override
    104         public void paint(Graphics g, MapView mv) {
     129         * Draw nodes last to overlap the segments they belong to.
     130         */
     131        @Override public void paint(Graphics g, MapView mv) {
    105132                SimplePaintVisitor visitor = new SimplePaintVisitor(g, mv);
    106                 for (OsmPrimitive osm : data.lineSegments)
    107                         if (!osm.isDeleted())
     133                for (OsmPrimitive osm : data.segments)
     134                        if (!osm.deleted)
    108135                                osm.visit(visitor);
    109136                for (OsmPrimitive osm : data.ways)
    110                         if (!osm.isDeleted())
     137                        if (!osm.deleted)
    111138                                osm.visit(visitor);
    112139                for (OsmPrimitive osm : data.nodes)
    113                         if (!osm.isDeleted())
     140                        if (!osm.deleted)
    114141                                osm.visit(visitor);
    115142                for (OsmPrimitive osm : data.getSelected())
    116                         if (!osm.isDeleted())
     143                        if (!osm.deleted)
    117144                                osm.visit(visitor);
    118         }
    119 
    120         @Override
    121         public String getToolTipText() {
     145                Main.main.getMapFrame().conflictDialog.paintConflicts(g, mv);
     146        }
     147
     148        @Override public String getToolTipText() {
    122149                return undeletedSize(data.nodes)+" nodes, "+
    123                         undeletedSize(data.lineSegments)+" segments, "+
    124                         undeletedSize(data.ways)+" streets.";
    125         }
    126 
    127         @Override
    128         public void mergeFrom(Layer from) {
    129                 MergeVisitor visitor = new MergeVisitor(data);
     150                undeletedSize(data.segments)+" segments, "+
     151                undeletedSize(data.ways)+" streets.";
     152        }
     153
     154        @Override public void mergeFrom(Layer from) {
     155                final MergeVisitor visitor = new MergeVisitor(data);
    130156                for (OsmPrimitive osm : ((OsmDataLayer)from).data.allPrimitives())
    131157                        osm.visit(visitor);
    132158                visitor.fixReferences();
    133         }
    134 
    135         @Override
    136         public boolean isMergable(Layer other) {
     159                if (visitor.conflicts.isEmpty())
     160                        return;
     161                Main.main.getMapFrame().conflictDialog.add(visitor.conflicts);
     162        }
     163
     164        @Override public boolean isMergable(Layer other) {
    137165                return other instanceof OsmDataLayer;
    138166        }
    139167
    140         @Override
    141         public void visitBoundingBox(BoundingXYVisitor v) {
     168        @Override public void visitBoundingBox(BoundingXYVisitor v) {
    142169                for (Node n : data.nodes)
    143170                        v.visit(n);
     
    150177                return commands.isEmpty() ? null : commands.getLast();
    151178        }
    152        
     179
    153180        /**
    154181         * Execute the command and add it to the intern command queue. Also mark all
     
    214241                        for (Iterator<Node> it = data.nodes.iterator(); it.hasNext();)
    215242                                cleanIterator(it, processedSet);
    216                         for (Iterator<LineSegment> it = data.lineSegments.iterator(); it.hasNext();)
     243                        for (Iterator<Segment> it = data.segments.iterator(); it.hasNext();)
    217244                                cleanIterator(it, processedSet);
    218245                        for (Iterator<Way> it = data.ways.iterator(); it.hasNext();)
     
    221248
    222249                // update the modified flag
    223                
     250
    224251                if (fromDisk && processed != null && !dataAdded)
    225252                        return; // do nothing when uploading non-harmful changes.
    226                
     253
    227254                // modified if server changed the data (esp. the id).
    228255                uploadedModified = fromDisk && processed != null && dataAdded;
     
    246273                        return;
    247274                osm.modified = false;
    248                 osm.modifiedProperties = false;
    249                 if (osm.isDeleted())
     275                if (osm.deleted)
    250276                        it.remove();
    251277        }
     
    280306                int size = 0;
    281307                for (OsmPrimitive osm : list)
    282                         if (!osm.isDeleted())
     308                        if (!osm.deleted)
    283309                                size++;
    284310                return size;
    285311        }
    286312
    287         @Override
    288         public Object getInfoComponent() {
    289                 final int[] normal = new int[3];               
    290                 final int[] deleted = new int[3];
    291                 final String[] names = {"node", "segment", "way"};
    292                 Visitor counter = new Visitor(){
    293                         private void inc(OsmPrimitive osm, int i) {
    294                                 normal[i]++;
    295                                 if (osm.isDeleted())
    296                                         deleted[i]++;
    297                         }
    298                         public void visit(Node n) {
    299                                 inc(n, 0);
    300                         }
    301                         public void visit(LineSegment ls) {
    302                                 inc(ls, 1);
    303                         }
    304                         public void visit(Way w) {
    305                                 inc(w, 2);
    306                         }
    307                 };
     313        @Override public Object getInfoComponent() {
     314                DataCountVisitor counter = new DataCountVisitor();
    308315                for (OsmPrimitive osm : data.allPrimitives())
    309316                        osm.visit(counter);
    310 
    311317                JPanel p = new JPanel(new GridBagLayout());
    312318                p.add(new JLabel(name+" consists of:"), GBC.eol());
    313                 for (int i = 0; i < normal.length; ++i) {
    314                         String s = normal[i]+" "+names[i]+(normal[i] != 1 ?"s":"");
    315                         if (deleted[i] > 0)
    316                                 s += " ("+deleted[i]+" deleted)";
    317                         p.add(new JLabel(s, ImageProvider.get("data", names[i]), JLabel.HORIZONTAL), GBC.eol().insets(15,0,0,0));
     319                for (int i = 0; i < counter.normal.length; ++i) {
     320                        String s = counter.normal[i]+" "+counter.names[i]+(counter.normal[i] != 1 ?"s":"");
     321                        if (counter.deleted[i] > 0)
     322                                s += " ("+counter.deleted[i]+" deleted)";
     323                        p.add(new JLabel(s, ImageProvider.get("data", counter.names[i]), JLabel.HORIZONTAL), GBC.eol().insets(15,0,0,0));
    318324                }
    319325                return p;
    320326        }
     327
     328        @Override public void addMenuEntries(JPopupMenu menu) {
     329                menu.add(new JMenuItem(new SaveAction()));
     330                menu.add(new JMenuItem(new GpxExportAction(this)));
     331                menu.addSeparator();
     332                menu.add(new LayerListPopup.InfoAction(this));
     333        }
    321334}
  • src/org/openstreetmap/josm/gui/layer/RawGpsDataLayer.java

    r78 r86  
    44import java.awt.Graphics;
    55import java.awt.Point;
     6import java.awt.event.ActionEvent;
     7import java.awt.event.ActionListener;
    68import java.util.Collection;
    79
    810import javax.swing.Icon;
     11import javax.swing.JColorChooser;
     12import javax.swing.JMenuItem;
     13import javax.swing.JOptionPane;
     14import javax.swing.JPopupMenu;
    915
    1016import org.openstreetmap.josm.Main;
     17import org.openstreetmap.josm.actions.GpxExportAction;
    1118import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    1219import org.openstreetmap.josm.data.coor.EastNorth;
     
    1421import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    1522import org.openstreetmap.josm.gui.MapView;
     23import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    1624import org.openstreetmap.josm.tools.ColorHelper;
    1725import org.openstreetmap.josm.tools.ImageProvider;
     
    5765         * Return a static icon.
    5866         */
    59         @Override
    60         public Icon getIcon() {
     67        @Override public Icon getIcon() {
    6168                if (icon == null)
    6269                        icon = ImageProvider.get("layer", "rawgps");
     
    6471        }
    6572
    66         @Override
    67         public void paint(Graphics g, MapView mv) {
     73        @Override public void paint(Graphics g, MapView mv) {
    6874                String gpsCol = Main.pref.get("color.gps point");
    6975                String gpsColSpecial = Main.pref.get("color.layer "+name);
     
    8995        }
    9096
    91         @Override
    92         public String getToolTipText() {
     97        @Override public String getToolTipText() {
    9398                int points = 0;
    9499                for (Collection<GpsPoint> c : data)
     
    97102        }
    98103
    99         @Override
    100         public void mergeFrom(Layer from) {
     104        @Override public void mergeFrom(Layer from) {
    101105                RawGpsDataLayer layer = (RawGpsDataLayer)from;
    102106                data.addAll(layer.data);
    103107        }
    104108
    105         @Override
    106         public boolean isMergable(Layer other) {
     109        @Override public boolean isMergable(Layer other) {
    107110                return other instanceof RawGpsDataLayer;
    108111        }
    109112
    110         @Override
    111         public void visitBoundingBox(BoundingXYVisitor v) {
     113        @Override public void visitBoundingBox(BoundingXYVisitor v) {
    112114                for (Collection<GpsPoint> c : data)
    113115                        for (GpsPoint p : c)
     
    115117        }
    116118
    117         @Override
    118         public Object getInfoComponent() {
     119        @Override public Object getInfoComponent() {
    119120                StringBuilder b = new StringBuilder();
    120121                int points = 0;
     
    126127                return "<html>"+name+" consists of "+data.size()+" tracks ("+points+" points)<br>"+b.toString();
    127128        }
     129
     130        @Override public void addMenuEntries(JPopupMenu menu) {
     131                menu.add(new JMenuItem(new GpxExportAction(this)));
     132               
     133                JMenuItem color = new JMenuItem("Customize Color", ImageProvider.get("colorchooser"));
     134                color.addActionListener(new ActionListener(){
     135                        public void actionPerformed(ActionEvent e) {
     136                                String col = Main.pref.get("color.layer "+name, Main.pref.get("color.gps point", ColorHelper.color2html(Color.gray)));
     137                                JColorChooser c = new JColorChooser(ColorHelper.html2color(col));
     138                                Object[] options = new Object[]{"OK", "Cancel", "Default"};
     139                                int answer = JOptionPane.showOptionDialog(Main.main, c, "Choose a color", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
     140                                switch (answer) {
     141                                case 0:
     142                                        Main.pref.put("color.layer "+name, ColorHelper.color2html(c.getColor()));
     143                                        break;
     144                                case 1:
     145                                        return;
     146                                case 2:
     147                                        Main.pref.put("color.layer "+name, null);
     148                                        break;
     149                                }
     150                                Main.main.repaint();
     151                        }
     152                });
     153                menu.add(color);
     154               
     155                menu.addSeparator();
     156                menu.add(new LayerListPopup.InfoAction(this));
     157    }
    128158}
  • src/org/openstreetmap/josm/gui/layer/WmsServerLayer.java

    r79 r86  
    66
    77import javax.swing.Icon;
     8import javax.swing.JPopupMenu;
    89
    910import org.openstreetmap.josm.Main;
     
    1314import org.openstreetmap.josm.data.projection.Projection;
    1415import org.openstreetmap.josm.gui.MapView;
     16import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    1517import org.openstreetmap.josm.tools.ImageProvider;
    1618import org.openstreetmap.josm.tools.TileCache;
     
    4345        }
    4446
    45         @Override
    46         public Icon getIcon() {
     47        @Override public Icon getIcon() {
    4748                return icon;
    4849        }
    4950
    50         @Override
    51         public String getToolTipText() {
     51        @Override public String getToolTipText() {
    5252                return "WMS layer: "+url;
    5353        }
    5454
    55         @Override
    56         public boolean isMergable(Layer other) {
     55        @Override public boolean isMergable(Layer other) {
    5756                return false;
    5857        }
    5958
    60         @Override
    61         public void mergeFrom(Layer from) {
     59        @Override public void mergeFrom(Layer from) {
    6260        }
    6361
    64         @Override
    65         public void paint(Graphics g, final MapView mv) {
     62        @Override public void paint(Graphics g, final MapView mv) {
    6663//              EastNorth max = mv.getEastNorth(mv.getWidth(),0);
    6764//              EastNorth min = mv.getEastNorth(0,mv.getHeight());
     
    9087        }
    9188
    92         @Override
    93         public void visitBoundingBox(BoundingXYVisitor v) {
     89        @Override public void visitBoundingBox(BoundingXYVisitor v) {
    9490                // doesn't have a bounding box
    9591        }
    9692
    97         @Override
    98         public Object getInfoComponent() {
     93        @Override public Object getInfoComponent() {
    9994                return getToolTipText();
    10095        }
     96
     97        @Override public void addMenuEntries(JPopupMenu menu) {
     98                menu.addSeparator();
     99                menu.add(new LayerListPopup.InfoAction(this));
     100    }
    101101}
  • src/org/openstreetmap/josm/io/GpxReader.java

    r80 r86  
    1515import org.openstreetmap.josm.data.coor.LatLon;
    1616import org.openstreetmap.josm.data.osm.DataSet;
    17 import org.openstreetmap.josm.data.osm.LineSegment;
     17import org.openstreetmap.josm.data.osm.Segment;
    1818import org.openstreetmap.josm.data.osm.Node;
    1919import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    104104                }
    105105
    106                 // read ways (and line segments)
     106                // read ways (and segments)
    107107                for (Object wayElement : e.getChildren("trk", GPX))
    108108                        parseWay((Element)wayElement, data);
     
    114114               
    115115                // clean up the data a bit (remove broken stuff)
    116                 // remove line segments with from==to
    117                 for (Iterator<LineSegment> it = data.lineSegments.iterator(); it.hasNext();) {
    118                         LineSegment ls = it.next();
     116                // remove segments with from==to
     117                for (Iterator<Segment> it = data.segments.iterator(); it.hasNext();) {
     118                        Segment ls = it.next();
    119119                        if (ls.from.equals(ls.to)) {
    120120                                it.remove();
     
    123123                        }
    124124                }
    125                 // remove double line segments (remove only subsequent doubles yet)
     125                // remove double segments (remove only subsequent doubles yet)
    126126                for (Iterator<Way> it = data.ways.iterator(); it.hasNext();) {
    127                         LineSegment ls = null;
    128                         for (Iterator<LineSegment> its = it.next().segments.iterator(); its.hasNext();) {
    129                                 LineSegment cur = its.next();
     127                        Segment ls = null;
     128                        for (Iterator<Segment> its = it.next().segments.iterator(); its.hasNext();) {
     129                                Segment cur = its.next();
    130130                                if (ls != null && ls.equals(cur))
    131131                                        its.remove();
     
    150150        private void parseWay(Element e, DataSet ds) {
    151151                Way way = new Way();
    152                 boolean realLineSegment = false; // is this way just a fake?
     152                boolean realSegment = false; // is this way just a fake?
    153153
    154154                for (Object o : e.getChildren()) {
     
    162162                                                start = node;
    163163                                        else {
    164                                                 LineSegment lineSegment = new LineSegment(start, node);
    165                                                 parseKeyValueExtensions(lineSegment, child.getChild("extensions", GPX));
    166                                                 lineSegment = (LineSegment)getNewIfSeenBefore(lineSegment);
    167                                                 way.segments.add(lineSegment);
     164                                                Segment segment = new Segment(start, node);
     165                                                parseKeyValueExtensions(segment, child.getChild("extensions", GPX));
     166                                                segment = (Segment)getNewIfSeenBefore(segment);
     167                                                way.segments.add(segment);
    168168                                                start = node;
    169169                                        }
     
    172172                                parseKeyValueExtensions(way, child);
    173173                                if (child.getChild("segment", JOSM) != null)
    174                                         realLineSegment = true;
     174                                        realSegment = true;
    175175                        } else if (child.getName().equals("link"))
    176176                                parseKeyValueLink(way, child);
     
    179179                }
    180180                way = (Way)getNewIfSeenBefore(way);
    181                 ds.lineSegments.addAll(way.segments);
    182                 if (!realLineSegment)
     181                ds.segments.addAll(way.segments);
     182                if (!realSegment)
    183183                        ds.ways.add(way);
    184184        }
     
    240240                                newCreatedPrimitives.put(osm.id, osm);
    241241                        osm.modified = e.getChild("modified", JOSM) != null;
    242                         osm.setDeleted(e.getChild("deleted", JOSM) != null);
    243                         osm.modifiedProperties = e.getChild("modifiedProperties", JOSM) != null;
     242                        osm.delete(e.getChild("deleted", JOSM) != null);
    244243                }
    245244        }
  • src/org/openstreetmap/josm/io/GpxWriter.java

    r79 r86  
    1919import org.openstreetmap.josm.data.coor.LatLon;
    2020import org.openstreetmap.josm.data.osm.DataSet;
    21 import org.openstreetmap.josm.data.osm.LineSegment;
     21import org.openstreetmap.josm.data.osm.Segment;
    2222import org.openstreetmap.josm.data.osm.Node;
    2323import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    108108                // for getting all unreferenced waypoints in the wpt-list
    109109                LinkedList<Node> unrefNodes = new LinkedList<Node>(ds.nodes);
    110                 // for getting all unreferenced line segments
    111                 LinkedList<LineSegment> unrefLs = new LinkedList<LineSegment>(ds.lineSegments);
     110                // for getting all unreferenced segments
     111                LinkedList<Segment> unrefLs = new LinkedList<Segment>(ds.segments);
    112112
    113113                // ways
    114114                for (Way t : ds.ways) {
    115                         if (t.isDeleted() && t.id == 0)
     115                        if (t.deleted && t.id == 0)
    116116                                continue;
    117117                        Element tElem = new Element("trk", GPX);
     
    129129                        addPropertyExtensions(tElem, keys, t);
    130130
    131                         // line segments
    132                         for (LineSegment ls : t.segments) {
    133                                 tElem.getChildren().add(parseLineSegment(ls));
     131                        // segments
     132                        for (Segment ls : t.segments) {
     133                                tElem.getChildren().add(parseSegment(ls));
    134134                                unrefNodes.remove(ls.from);
    135135                                unrefNodes.remove(ls.to);
     
    140140                }
    141141               
    142                 // encode pending line segments as ways
    143                 for (LineSegment ls : unrefLs) {
    144                         if (ls.isDeleted() && ls.id == 0)
     142                // encode pending segments as ways
     143                for (Segment ls : unrefLs) {
     144                        if (ls.deleted && ls.id == 0)
    145145                                continue;
    146146                        Element t = new Element("trk", GPX);
    147                         t.getChildren().add(parseLineSegment(ls));
     147                        t.getChildren().add(parseSegment(ls));
    148148                        unrefNodes.remove(ls.from);
    149149                        unrefNodes.remove(ls.to);
     
    156156                // waypoints (missing nodes)
    157157                for (Node n : unrefNodes) {
    158                         if (n.isDeleted() && n.id == 0)
     158                        if (n.deleted && n.id == 0)
    159159                                continue;
    160160                        e.getChildren().add(parseWaypoint(n, "wpt"));
     
    179179
    180180        /**
    181          * Parse a line segment and store it into a JDOM-Element. Return that element.
     181         * Parse a segment and store it into a JDOM-Element. Return that element.
    182182         */
    183183        @SuppressWarnings("unchecked")
    184         private Element parseLineSegment(LineSegment ls) {
     184        private Element parseSegment(Segment ls) {
    185185                Element lsElem = new Element("trkseg", GPX);
    186186                addPropertyExtensions(lsElem, ls.keys, ls);
     
    306306                        extensions.add(modElement);
    307307                }
    308                 if (osm.isDeleted()) {
     308                if (osm.deleted) {
    309309                        Element modElement = new Element("deleted", JOSM);
    310                         extensions.add(modElement);
    311                 }
    312                 if (osm.modifiedProperties) {
    313                         Element modElement = new Element("modifiedProperties", JOSM);
    314310                        extensions.add(modElement);
    315311                }
     
    355351
    356352        /**
    357          * Export the dataset to gpx. Only the physical line segment structure is
     353         * Export the dataset to gpx. Only the physical segment structure is
    358354         * exported. To do this, the list of ways is processed. If a way span a
    359          * sequence of line segments, this is added as one trkseg.
    360          * Then, all remaining line segments are added in one extra trk. Finally,
     355         * sequence of segments, this is added as one trkseg.
     356         * Then, all remaining segments are added in one extra trk. Finally,
    361357         * all remaining nodes are added as wpt.
    362358         */
     
    371367                Bounds b = new Bounds(new LatLon(Double.MAX_VALUE, Double.MAX_VALUE), new LatLon(Double.MIN_VALUE, Double.MIN_VALUE));
    372368                for (Node n : data.nodes)
    373                         if (!n.isDeleted())
     369                        if (!n.deleted)
    374370                                b.extend(n.coor);
    375371                out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
     
    378374                // add ways
    379375                for (Way w : data.ways) {
    380                         if (w.isDeleted())
     376                        if (w.deleted)
    381377                                continue;
    382378                        out.println("  <trk>");
    383                         LineSegment oldLs = null;
    384                         for (LineSegment ls : w.segments) {
     379                        Segment oldLs = null;
     380                        for (Segment ls : w.segments) {
    385381                                // end old segemnt, if no longer match a chain
    386382                                if (oldLs != null && !oldLs.to.coor.equals(ls.from.coor)) {
     
    408404                }
    409405               
    410                 // add remaining line segments
    411                 Collection<LineSegment> lineSegments = new LinkedList<LineSegment>();
     406                // add remaining segments
     407                Collection<Segment> segments = new LinkedList<Segment>();
    412408                for (OsmPrimitive osm : all)
    413                         if (osm instanceof LineSegment)
    414                                 lineSegments.add((LineSegment)osm);
    415                 if (!lineSegments.isEmpty()) {
     409                        if (osm instanceof Segment)
     410                                segments.add((Segment)osm);
     411                if (!segments.isEmpty()) {
    416412                        out.println("  <trk>");
    417                         for (LineSegment ls : lineSegments) {
     413                        for (Segment ls : segments) {
    418414                                out.println("    <trkseg>");
    419415                                outputNode(ls.from, false);
  • src/org/openstreetmap/josm/io/OsmConnection.java

    r75 r86  
    3737                boolean cancelled = false;
    3838
    39                 @Override
    40                 protected PasswordAuthentication getPasswordAuthentication() {
     39                @Override protected PasswordAuthentication getPasswordAuthentication() {
    4140                        String username = Main.pref.get("osm-server.username");
    4241                        String password = Main.pref.get("osm-server.password");
  • src/org/openstreetmap/josm/io/OsmReader.java

    r82 r86  
    1111import org.openstreetmap.josm.data.coor.LatLon;
    1212import org.openstreetmap.josm.data.osm.DataSet;
    13 import org.openstreetmap.josm.data.osm.LineSegment;
     13import org.openstreetmap.josm.data.osm.Segment;
    1414import org.openstreetmap.josm.data.osm.Node;
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    5050         * All read segents so far.
    5151         */
    52         private Map<Long, LineSegment> lineSegments = new HashMap<Long, LineSegment>();
     52        private Map<Long, Segment> segments = new HashMap<Long, Segment>();
    5353       
    5454        /**
     
    7070        }
    7171
    72         @Override
    73         public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
     72        @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
    7473                try {
    7574                        if (qName.equals("osm")) {
     
    8988                                if (from == null || to == null)
    9089                                        throw new SAXException("Segment "+atts.getValue("id")+" is missing its nodes.");
    91                                 current = new LineSegment(from, to);
     90                                current = new Segment(from, to);
    9291                                readCommon(atts);
    93                                 lineSegments.put(current.id, (LineSegment)current);
     92                                segments.put(current.id, (Segment)current);
    9493                        } else if (qName.equals("way")) {
    9594                                current = new Way();
     
    9998                                        long id = getLong(atts, "id");
    10099                                        if (id == 0)
    101                                                 throw new SAXException("Incomplete line segment with id=0");
    102                                         LineSegment ls = lineSegments.get(id);
     100                                                throw new SAXException("Incomplete segment with id=0");
     101                                        Segment ls = segments.get(id);
    103102                                        if (ls == null) {
    104                                                 ls = new LineSegment(id); // incomplete line segment
    105                                                 lineSegments.put(id, ls);
     103                                                ls = new Segment(id); // incomplete segment
     104                                                segments.put(id, ls);
    106105                                                adder.visit(ls);
    107106                                        }
     
    119118
    120119       
    121         @Override
    122         public void endElement(String namespaceURI, String localName, String qName) {
     120        @Override public void endElement(String namespaceURI, String localName, String qName) {
    123121                if (qName.equals("node") || qName.equals("segment") || qName.equals("way") || qName.equals("area")) {
    124122                        current.visit(adder);
     
    138136                        try {
    139137                                DateFormat df = new SimpleDateFormat("y-M-d H:m:s");
    140                     current.lastModified = df.parse(time);
     138                    current.timestamp = df.parse(time);
    141139            } catch (ParseException e) {
    142140                    e.printStackTrace();
     
    146144               
    147145                String action = atts.getValue("action");
    148                 if ("delete".equals(action))
    149                         current.setDeleted(true);
    150                 else if ("modify".equals(action)) {
     146                if (action == null)
     147                        return;
     148                if (action.equals("delete"))
     149                        current.delete(true);
     150                else if (action.startsWith("modify"))
    151151                        current.modified = true;
    152                         current.modifiedProperties = true;
    153                 } else if ("modify/object".equals(action))
    154                         current.modified = true;
    155                 else if ("modify/property".equals(action))
    156                         current.modifiedProperties = true;
    157152        }
    158153
  • src/org/openstreetmap/josm/io/OsmReaderOld.java

    r71 r86  
    1111import org.openstreetmap.josm.data.coor.LatLon;
    1212import org.openstreetmap.josm.data.osm.DataSet;
    13 import org.openstreetmap.josm.data.osm.LineSegment;
     13import org.openstreetmap.josm.data.osm.Segment;
    1414import org.openstreetmap.josm.data.osm.Node;
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    8080                        return parseNode(e);
    8181                else if (e.getName().equals("segment"))
    82                         return parseLineSegment(e, data);
     82                        return parseSegment(e, data);
    8383                else if (e.getName().equals("way"))
    8484                        return parseWay(e, data);
     
    115115
    116116        /**
    117          * Parse and return an line segment. The node information of the "from" and
     117         * Parse and return an segment. The node information of the "from" and
    118118         * "to" attributes must already be in the dataset.
    119          * @param e             The line segment element to parse.
     119         * @param e             The segment element to parse.
    120120         * @param data  The dataset to obtain the node information from.
    121          * @return The parsed line segment.
     121         * @return The parsed segment.
    122122         * @throws JDOMException In case of parsing errors.
    123123         */
    124         private LineSegment parseLineSegment(Element e, DataSet data) throws JDOMException {
     124        private Segment parseSegment(Element e, DataSet data) throws JDOMException {
    125125                long startId = Long.parseLong(e.getAttributeValue("from"));
    126126                long endId = Long.parseLong(e.getAttributeValue("to"));
     
    135135                if (start == null || end == null)
    136136                        throw new JDOMException("The 'from' or 'to' object has not been transfered before.");
    137                 LineSegment ls = new LineSegment(start, end);
     137                Segment ls = new Segment(start, end);
    138138                parseCommon(ls, e);
    139139                return ls;
     
    154154                        Element child = (Element)o;
    155155                        long id = Long.parseLong(child.getAttributeValue("uid"));
    156                         LineSegment ls = findLineSegment(data.lineSegments, id);
     156                        Segment ls = findSegment(data.segments, id);
    157157                        way.segments.add(ls);
    158158                }
     
    189189               
    190190                String action = e.getAttributeValue("action");
    191                 if ("delete".equals(action))
    192                         data.setDeleted(true);
    193                 else if ("modify".equals(action))
    194                         data.modified = data.modifiedProperties = true;
    195                 else if ("modify/property".equals(action))
    196                         data.modifiedProperties = true;
    197                 else if ("modify/object".equals(action))
     191                if (action == null)
     192                        return;
     193                if (action.equals("delete"))
     194                        data.delete(true);
     195                else if (action.startsWith("modify"))
    198196                        data.modified = true;
    199197        }
     
    218216                        if (osm.id == id)
    219217                                return osm;
    220                 for (OsmPrimitive osm : data.lineSegments)
     218                for (OsmPrimitive osm : data.segments)
    221219                        if (osm.id == id)
    222220                                return osm;
     
    230228         * Search for a segment in a collection by comparing the id.
    231229         */
    232         private LineSegment findLineSegment(Collection<LineSegment> segments, long id) throws JDOMException {
    233                 for (LineSegment ls : segments)
     230        private Segment findSegment(Collection<Segment> segments, long id) throws JDOMException {
     231                for (Segment ls : segments)
    234232                        if (ls.id == id)
    235233                                return ls;
    236                 throw new JDOMException("Unknown line segment reference: "+id);
     234                throw new JDOMException("Unknown segment reference: "+id);
    237235        }
    238236}
  • src/org/openstreetmap/josm/io/OsmServerWriter.java

    r84 r86  
    1616import org.jdom.JDOMException;
    1717import org.openstreetmap.josm.Main;
    18 import org.openstreetmap.josm.data.osm.LineSegment;
     18import org.openstreetmap.josm.data.osm.Segment;
    1919import org.openstreetmap.josm.data.osm.Node;
    2020import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    6565         */
    6666        public void visit(Node n) {
    67                 if (n.id == 0 && !n.isDeleted() && n.get("created_by") == null) {
     67                if (n.id == 0 && !n.deleted && n.get("created_by") == null) {
    6868                        n.put("created_by", "JOSM");
    6969                        sendRequest("PUT", "node", n, true);
    70                 } else if (n.isDeleted()) {
     70                } else if (n.deleted) {
    7171                        sendRequest("DELETE", "node", n, false);
    7272                } else {
     
    7777
    7878        /**
    79          * Upload a line segment (without the nodes).
     79         * Upload a segment (without the nodes).
    8080         */
    81         public void visit(LineSegment ls) {
    82                 if (ls.id == 0 && !ls.isDeleted() && ls.get("created_by") == null) {
     81        public void visit(Segment ls) {
     82                if (ls.id == 0 && !ls.deleted && ls.get("created_by") == null) {
    8383                        ls.put("created_by", "JOSM");
    8484                        sendRequest("PUT", "segment", ls, true);
    85                 } else if (ls.isDeleted()) {
     85                } else if (ls.deleted) {
    8686                        sendRequest("DELETE", "segment", ls, false);
    8787                } else {
     
    9292
    9393        /**
    94          * Upload a whole way with the complete line segment id list.
     94         * Upload a whole way with the complete segment id list.
    9595         */
    9696        public void visit(Way w) {
    97                 if (w.id == 0 && !w.isDeleted() && w.get("created_by") == null) {
     97                if (w.id == 0 && !w.deleted && w.get("created_by") == null) {
    9898                        w.put("created_by", "JOSM");
    9999                        sendRequest("PUT", "way", w, true);
    100                 } else if (w.isDeleted()) {
     100                } else if (w.deleted) {
    101101                        sendRequest("DELETE", "way", w, false);
    102102                } else {
  • src/org/openstreetmap/josm/io/OsmWriter.java

    r82 r86  
    88
    99import org.openstreetmap.josm.data.osm.DataSet;
    10 import org.openstreetmap.josm.data.osm.LineSegment;
     10import org.openstreetmap.josm.data.osm.Segment;
    1111import org.openstreetmap.josm.data.osm.Node;
    1212import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    5151                for (Node n : ds.nodes)
    5252                        writer.visit(n);
    53                 for (LineSegment ls : ds.lineSegments)
     53                for (Segment ls : ds.segments)
    5454                        writer.visit(ls);
    5555                for (Way w : ds.ways)
     
    8080        }
    8181
    82         public void visit(LineSegment ls) {
     82        public void visit(Segment ls) {
    8383                if (ls.incomplete)
    84                         return; // Do not write an incomplete line segment
     84                        return; // Do not write an incomplete segment
    8585                addCommon(ls, "segment");
    8686                out.print(" from='"+getUsedId(ls.from)+"' to='"+getUsedId(ls.to)+"'");
     
    9191                addCommon(w, "way");
    9292                out.println(">");
    93                 for (LineSegment ls : w.segments)
     93                for (Segment ls : w.segments)
    9494                        out.println("    <seg id='"+getUsedId(ls)+"' />");
    9595                addTags(w, "way", false);
     
    130130                if (!osmConform) {
    131131                        String action = null;
    132                         if (osm.isDeleted())
     132                        if (osm.deleted)
    133133                                action = "delete";
    134                         else if (osm.modified && osm.modifiedProperties)
     134                        else if (osm.modified)
    135135                                action = "modify";
    136                         else if (osm.modified && !osm.modifiedProperties)
    137                                 action = "modify/object";
    138                         else if (!osm.modified && osm.modifiedProperties)
    139                                 action = "modify/property";
    140136                        if (action != null)
    141137                                out.print(" action='"+action+"'");
    142138                }
    143                 if (osm.lastModified != null) {
    144                         String time = new SimpleDateFormat("y-M-d H:m:s").format(osm.lastModified);
     139                if (osm.timestamp != null) {
     140                        String time = new SimpleDateFormat("y-M-d H:m:s").format(osm.timestamp);
    145141                        out.print(" timestamp='"+time+"'");
    146142                }
  • src/org/openstreetmap/josm/test/GpxWriterTest.java

    r71 r86  
    3131        @Bug(47)
    3232        public void testDeleteNewDoesReallyRemove() throws JDOMException, IOException {
    33                 ds.ways.iterator().next().setDeleted(true);
     33                ds.ways.iterator().next().delete(true);
    3434                root = reparse();
    3535                assertEquals("way has vanished and 3 trk (segments) left", 3, root.getChildren("trk", GPX).size());
     
    7777
    7878
    79         @Override
    80         protected void setUp() throws Exception {
     79        @Override protected void setUp() throws Exception {
    8180                super.setUp();
    8281                ds = DataSetTestCaseHelper.createCommon();
  • src/org/openstreetmap/josm/test/MergeVisitorTest.java

    r71 r86  
    11package org.openstreetmap.josm.test;
     2
     3import java.util.Date;
    24
    35import junit.framework.TestCase;
     
    57import org.openstreetmap.josm.data.coor.LatLon;
    68import org.openstreetmap.josm.data.osm.DataSet;
    7 import org.openstreetmap.josm.data.osm.LineSegment;
    89import org.openstreetmap.josm.data.osm.Node;
    910import org.openstreetmap.josm.data.osm.OsmPrimitive;
     11import org.openstreetmap.josm.data.osm.Segment;
    1012import org.openstreetmap.josm.data.osm.visitor.MergeVisitor;
    1113import org.openstreetmap.josm.test.framework.Bug;
     
    1517
    1618       
     19        private DataSet ds;
     20        private Node dsNode;
     21        private Node n;
     22        private MergeVisitor v;
     23
     24        @Override protected void setUp() throws Exception {
     25                ds = new DataSet();
     26                dsNode = DataSetTestCaseHelper.createNode(ds);
     27                v = new MergeVisitor(ds);
     28                n = DataSetTestCaseHelper.createNode(null);
     29    }
     30
     31
     32        public void testNodesMergeUpdate() {
     33                dsNode.id = 1;
     34                n.id = 1;
     35                n.timestamp = new Date();
     36                v.visit(n);
     37                assertEquals(dsNode, n);
     38        }
     39        public void testNodesMergeModified() {
     40                dsNode.id = 1;
     41                n.id = 1;
     42                n.modified = true;
     43                v.visit(n);
     44                assertEquals(dsNode, n);
     45        }
     46        public void testNodesConflictBothModified() {
     47                n.modified = true;
     48                dsNode.modified = true;
     49                v.visit(n);
     50                assertEquals(1, v.conflicts.size());
     51                assertFalse(n.equals(dsNode));
     52        }
     53        public void testNodesConflict() {
     54                dsNode.id = 1;
     55                dsNode.timestamp = new Date();
     56                n.id = 1;
     57                n.modified = true;
     58                n.timestamp = new Date(dsNode.timestamp.getTime()-1);
     59                v.visit(n);
     60                assertEquals(1, v.conflicts.size());
     61                assertSame(dsNode, v.conflicts.keySet().iterator().next());
     62                assertSame(n, v.conflicts.values().iterator().next());
     63        }
     64        public void testNodesConflict2() {
     65                dsNode.id = 1;
     66                dsNode.timestamp = new Date();
     67                dsNode.modified = true;
     68                n.id = 1;
     69                n.timestamp = new Date(dsNode.timestamp.getTime()+1);
     70                v.visit(n);
     71                assertEquals(1, v.conflicts.size());
     72        }
     73        public void testNodesConflictModifyDelete() {
     74                dsNode.id = 1;
     75                dsNode.modified = true;
     76                n.id = 1;
     77                n.delete(true);
     78                v.visit(n);
     79                assertEquals(1, v.conflicts.size());
     80        }
     81        public void testNodesMergeSamePosition() {
     82                n.id = 1; // new node comes from server
     83                dsNode.modified = true; // our node is modified
     84                dsNode.coor = new LatLon(n.coor.lat(), n.coor.lon());
     85                v.visit(n);
     86                v.fixReferences();
     87                assertEquals(0, v.conflicts.size());
     88                assertEquals(1, dsNode.id);
     89                assertFalse("updating a new node clear the modified state", dsNode.modified);
     90        }
     91
     92        public void testFixReferencesConflicts() {
     93                // make two nodes mergable
     94                dsNode.id = 1;
     95                n.id = 1;
     96                n.timestamp = new Date();
     97                // have an old segment with the old node
     98                Segment sold = new Segment(dsNode, dsNode);
     99                sold.id = 23;
     100                sold.modified = true;
     101                ds.segments.add(sold);
     102                // have a conflicting segment point to the new node
     103                Segment s = new Segment(n,n);
     104                s.id = 23;
     105                s.modified = true;
     106
     107                v.visit(n); // merge
     108                assertEquals(n.timestamp, dsNode.timestamp);
     109                v.visit(s);
     110                v.fixReferences();
     111                assertSame(s.from, dsNode);
     112                assertSame(s.to, dsNode);
     113        }
     114       
     115        public void testNoConflictForSame() {
     116                dsNode.id = 1;
     117                dsNode.modified = true;
     118                n.cloneFrom(dsNode);
     119                v.visit(n);
     120                assertEquals(0, v.conflicts.size());
     121        }
     122
    17123        /**
    18          * Merge of an old line segment with a new one. This should
     124         * Merge of an old segment with a new one. This should
    19125         * be mergable (if the nodes matches).
    20126         */
    21         public void testMergeOldLineSegmentsWithNew() {
    22                 DataSet ds = new DataSet();
     127        public void testMergeOldSegmentsWithNew() {
    23128                Node[] n = createNodes(ds, 2);
    24                 LineSegment ls1 = DataSetTestCaseHelper.createLineSegment(ds, n[0], n[1]);
     129                Segment ls1 = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]);
    25130                ls1.id = 3;
    26131
    27132                Node newnode = new Node(new LatLon(n[1].coor.lat(), n[1].coor.lon()));
    28                 LineSegment newls = new LineSegment(n[0], newnode);
     133                Segment newls = new Segment(n[0], newnode);
    29134
    30                 MergeVisitor v = new MergeVisitor(ds);
    31135                v.visit(newls);
    32                 assertEquals("line segment should have been merged.", 1, ds.lineSegments.size());
     136                assertEquals("segment should have been merged.", 1, ds.segments.size());
    33137        }
    34138       
    35139        /**
    36          * Nodes beeing merged are equal but not the same.
     140         * Nodes beeing merged are equal but should be the same.
    37141         */
    38142        @Bug(54)
    39143        public void testEqualNotSame() {
    40                 // create a dataset with line segment a-b
    41                 DataSet ds = new DataSet();
     144                ds = new DataSet();
     145                // create a dataset with segment a-b
    42146                Node n[] = createNodes(ds, 2);
    43                 LineSegment ls1 = DataSetTestCaseHelper.createLineSegment(ds, n[0], n[1]);
     147                Segment ls1 = DataSetTestCaseHelper.createSegment(ds, n[0], n[1]);
    44148                ls1.id = 1;
    45                
    46                 // create an other dataset with line segment a'-c (a' is equal, but not same to a)
     149
     150                // create an other dataset with segment a'-c (a' is equal, but not same to a)
    47151                DataSet ds2 = new DataSet();
    48152                Node n2[] = createNodes(ds2, 2);
    49153                n2[0].coor = new LatLon(n[0].coor.lat(), n[0].coor.lon());
     154                n2[0].id = 0;
    50155                n2[1].id = 42;
    51                 LineSegment ls2 = DataSetTestCaseHelper.createLineSegment(ds, n2[0], n2[1]);
    52                
    53                 MergeVisitor v = new MergeVisitor(ds);
     156
     157                Segment ls2 = DataSetTestCaseHelper.createSegment(ds, n2[0], n2[1]);
     158                v = new MergeVisitor(ds);
    54159                for (OsmPrimitive osm : ds2.allPrimitives())
    55160                        osm.visit(v);
    56161                v.fixReferences();
    57                
     162
    58163                assertSame(ls1.from, ls2.from);
    59164        }
  • src/org/openstreetmap/josm/test/OsmWriterTest.java

    r71 r86  
    1414import org.jdom.JDOMException;
    1515import org.jdom.input.SAXBuilder;
     16import org.openstreetmap.josm.Main;
    1617import org.openstreetmap.josm.data.osm.DataSet;
    17 import org.openstreetmap.josm.data.osm.LineSegment;
     18import org.openstreetmap.josm.data.osm.Segment;
    1819import org.openstreetmap.josm.data.osm.Node;
    1920import org.openstreetmap.josm.data.osm.OsmPrimitive;
    20 import org.openstreetmap.josm.data.osm.Way;
     21import org.openstreetmap.josm.data.projection.Mercator;
    2122import org.openstreetmap.josm.io.OsmWriter;
    2223import org.openstreetmap.josm.test.framework.Bug;
     
    3435        private Node n4;
    3536        private Node n5;
    36         private LineSegment ls1;
    37         private LineSegment ls2;
    38         private LineSegment ls3;
    39         private Way w;
     37        private Segment ls1;
     38        private Segment ls2;
     39        private Segment ls3;
    4040       
    4141        private DataSet ds;
    4242        private Element osm;
    4343        private List<Element> nodes;
    44         private List<Element> lineSegments;
     44        private List<Element> segments;
    4545        private List<Element> ways;
    4646        private StringWriter out;
    4747       
     48        public OsmWriterTest() {
     49                Main.proj = new Mercator();
     50        }
    4851
    4952        public void testNode() throws Exception {
     
    7275        }
    7376       
    74         public void testLineSegment() throws Exception {
     77        public void testSegment() throws Exception {
    7578                ds = new DataSet();
    76                 LineSegment ls = DataSetTestCaseHelper.createLineSegment(ds, DataSetTestCaseHelper.createNode(ds), DataSetTestCaseHelper.createNode(ds));
     79                Segment ls = DataSetTestCaseHelper.createSegment(ds, DataSetTestCaseHelper.createNode(ds), DataSetTestCaseHelper.createNode(ds));
    7780                ls.put("foo", "bar");
    7881                reparse();
    79                 assertEquals(1, lineSegments.size());
     82                assertEquals(1, segments.size());
    8083                assertEquals("foo", getAttr(osm.getChild("segment"), "tag", 0, "k"));
    8184                assertEquals("bar", getAttr(osm.getChild("segment"), "tag", 0, "v"));
     
    9497                        ids.add(id);