Changeset 1750 in josm


Ignore:
Timestamp:
2009-07-08T21:50:32+02:00 (10 years ago)
Author:
Gubaer
Message:

new: replaced global conflict list by conflict list per layer, similar to datasets

Location:
trunk
Files:
8 added
51 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/Main.java

    r1722 r1750  
    150150        panel.setVisible(false);
    151151        panel.removeAll();
    152         if (map != null)
     152        if (map != null) {
    153153            map.fillPanel(panel);
    154         else {
     154        } else {
    155155            old.destroy();
    156156            panel.add(gettingStarted, BorderLayout.CENTER);
     
    169169        if (map != null) {
    170170            map.mapView.removeLayer(layer);
    171             if (layer instanceof OsmDataLayer)
     171            if (layer instanceof OsmDataLayer) {
    172172                ds = new DataSet();
    173             if (map.mapView.getAllLayers().isEmpty())
     173            }
     174            if (map.mapView.getAllLayers().isEmpty()) {
    174175                setMapFrame(null);
     176            }
    175177        }
    176178    }
     
    182184    public Main(SplashScreen splash) {
    183185        main = this;
    184 //        platform = determinePlatformHook();
     186        //        platform = determinePlatformHook();
    185187        platform.startupHook();
    186188        contentPane.add(panel, BorderLayout.CENTER);
    187189        panel.add(gettingStarted, BorderLayout.CENTER);
    188190
    189         if(splash != null) splash.setStatus(tr("Creating main GUI"));
     191        if(splash != null) {
     192            splash.setStatus(tr("Creating main GUI"));
     193        }
    190194        menu = new MainMenu();
    191195
     
    197201        contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
    198202        .put(Shortcut.registerShortcut("system:help", tr("Help"),
    199         KeyEvent.VK_F1, Shortcut.GROUP_DIRECT).getKeyStroke(), "Help");
     203                KeyEvent.VK_F1, Shortcut.GROUP_DIRECT).getKeyStroke(), "Help");
    200204        contentPane.getActionMap().put("Help", menu.help);
    201205
     
    223227    }
    224228    /**
    225      * @return The edit osm layer. If none exists, it will be created.
    226      */
    227     public final OsmDataLayer editLayer() {
    228         if (map == null || map.mapView.editLayer == null)
     229     * Replies the current edit layer. Creates one if no {@see OsmDataLayer}
     230     * exists. Replies null, if the currently active layer isn't an instance
     231     * of {@see OsmDataLayer}.
     232     *
     233     * @return the current edit layer
     234     */
     235    public final OsmDataLayer createOrGetEditLayer() {
     236        if (map == null || map.mapView.getEditLayer() == null) {
    229237            menu.newAction.actionPerformed(null);
    230         return map.mapView.editLayer;
     238        }
     239        return map.mapView.getEditLayer();
     240    }
     241
     242    /**
     243     * Replies true if this map view has an edit layer
     244     *
     245     * @return true if this map view has an edit layer
     246     */
     247    public boolean hasEditLayer() {
     248        if (map == null) return false;
     249        if (map.mapView == null) return false;
     250        if (map.mapView.getEditLayer() == null) return false;
     251        return true;
    231252    }
    232253
     
    263284        if(!Main.proj.equals(oldProj))
    264285        {
    265             if(b != null)
     286            if(b != null) {
    266287                map.mapView.zoomTo(b);
    267             /* TODO - remove layers with fixed projection */
     288                /* TODO - remove layers with fixed projection */
     289            }
    268290        }
    269291    }
     
    279301            try {
    280302                String laf = Main.pref.get("laf");
    281                 if(laf != null && laf.length() > 0)
     303                if(laf != null && laf.length() > 0) {
    282304                    UIManager.setLookAndFeel(laf);
     305                }
    283306            }
    284307            catch (final javax.swing.UnsupportedLookAndFeelException e) {
     
    310333                    x = Integer.valueOf(m.group(5));
    311334                    y = Integer.valueOf(m.group(7));
    312                     if (m.group(4).equals("-"))
     335                    if (m.group(4).equals("-")) {
    313336                        x = screenDimension.width - x - w;
    314                     if (m.group(6).equals("-"))
     337                    }
     338                    if (m.group(6).equals("-")) {
    315339                        y = screenDimension.height - y - h;
     340                    }
    316341                }
    317342                bounds = new Rectangle(x,y,w,h);
     
    324349            }
    325350        }
    326         if (bounds == null)
     351        if (bounds == null) {
    327352            bounds = !args.containsKey("no-maximize") ? new Rectangle(0,0,screenDimension.width,screenDimension.height) : new Rectangle(1000,740);
    328 
    329             // preinitialize a wait dialog for all early downloads (e.g. via command line)
    330             pleaseWaitDlg = new PleaseWaitDialog(null);
     353        }
     354
     355        // preinitialize a wait dialog for all early downloads (e.g. via command line)
     356        pleaseWaitDlg = new PleaseWaitDialog(null);
    331357    }
    332358
     
    335361        pleaseWaitDlg = new PleaseWaitDialog(parent);
    336362
    337         if (args.containsKey("download"))
    338             for (String s : args.get("download"))
     363        if (args.containsKey("download")) {
     364            for (String s : args.get("download")) {
    339365                downloadFromParamString(false, s);
    340         if (args.containsKey("downloadgps"))
    341             for (String s : args.get("downloadgps"))
     366            }
     367        }
     368        if (args.containsKey("downloadgps")) {
     369            for (String s : args.get("downloadgps")) {
    342370                downloadFromParamString(true, s);
    343         if (args.containsKey("selection"))
    344             for (String s : args.get("selection"))
     371            }
     372        }
     373        if (args.containsKey("selection")) {
     374            for (String s : args.get("selection")) {
    345375                SearchAction.search(s, SearchAction.SearchMode.add, false, false);
     376            }
     377        }
    346378    }
    347379
     
    360392            if (modified) {
    361393                final String msg = uploadedModified ? "\n"
    362                 +tr("Hint: Some changes came from uploading new data to the server.") : "";
    363                 int result = new ExtendedDialog(parent, tr("Unsaved Changes"),
    364                 new javax.swing.JLabel(tr("There are unsaved changes. Discard the changes and continue?")+msg),
    365                 new String[] {tr("Save and Exit"), tr("Discard and Exit"), tr("Cancel")},
    366                 new String[] {"save.png", "exit.png", "cancel.png"}).getValue();
    367 
    368                 // Save before exiting
    369                 if(result == 1) {
    370                     Boolean savefailed = false;
    371                     for (final Layer l : map.mapView.getAllLayers()) {
    372                         if (l instanceof OsmDataLayer && ((OsmDataLayer)l).isModified()) {
    373                             SaveAction save = new SaveAction(l);
    374                             if(!save.doSave())
    375                                 savefailed = true;
     394                        +tr("Hint: Some changes came from uploading new data to the server.") : "";
     395                        int result = new ExtendedDialog(parent, tr("Unsaved Changes"),
     396                                new javax.swing.JLabel(tr("There are unsaved changes. Discard the changes and continue?")+msg),
     397                                new String[] {tr("Save and Exit"), tr("Discard and Exit"), tr("Cancel")},
     398                                new String[] {"save.png", "exit.png", "cancel.png"}).getValue();
     399
     400                        // Save before exiting
     401                        if(result == 1) {
     402                            Boolean savefailed = false;
     403                            for (final Layer l : map.mapView.getAllLayers()) {
     404                                if (l instanceof OsmDataLayer && ((OsmDataLayer)l).isModified()) {
     405                                    SaveAction save = new SaveAction(l);
     406                                    if(!save.doSave()) {
     407                                        savefailed = true;
     408                                    }
     409                                }
     410                            }
     411                            return savefailed;
    376412                        }
    377                     }
    378                     return savefailed;
    379                 }
    380                 else if(result != 2) // Cancel exiting unless the 2nd button was clicked
    381                     return true;
     413                        else if(result != 2) // Cancel exiting unless the 2nd button was clicked
     414                            return true;
    382415            }
    383416        }
     
    388421        if (s.startsWith("http:")) {
    389422            final Bounds b = OsmUrlToBounds.parse(s);
    390             if (b == null)
     423            if (b == null) {
    391424                JOptionPane.showMessageDialog(Main.parent, tr("Ignoring malformed URL: \"{0}\"", s));
    392             else {
     425            } else {
    393426                //DownloadTask osmTask = main.menu.download.downloadTasks.get(0);
    394427                DownloadTask osmTask = new DownloadOsmTask();
     
    428461            platform = new PlatformHookWindows();
    429462        } else if (os.equals("Linux") || os.equals("Solaris") ||
    430             os.equals("SunOS") || os.equals("AIX") ||
    431             os.equals("FreeBSD") || os.equals("NetBSD") || os.equals("OpenBSD")) {
     463                os.equals("SunOS") || os.equals("AIX") ||
     464                os.equals("FreeBSD") || os.equals("NetBSD") || os.equals("OpenBSD")) {
    432465            platform = new PlatformHookUnixoid();
    433466        } else if (os.toLowerCase().startsWith("mac os x")) {
     
    468501                int x = (int)bounds.getX();
    469502                int y = (int)bounds.getY();
    470                 if (width > screenDimension.width)
     503                if (width > screenDimension.width) {
    471504                    width = screenDimension.width;
    472                 if (height > screenDimension.height)
     505                }
     506                if (height > screenDimension.height) {
    473507                    width = screenDimension.height;
    474                 if (x < 0)
     508                }
     509                if (x < 0) {
    475510                    x = 0;
    476                 if (y < 0)
     511                }
     512                if (y < 0) {
    477513                    y = 0;
     514                }
    478515                newGeometry = width + "x" + height + "+" + x + "+" + y;
    479516            }
  • trunk/src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r1662 r1750  
    88import java.awt.event.KeyEvent;
    99import java.util.Collection;
     10import java.util.HashSet;
    1011
    1112import javax.swing.JOptionPane;
     
    7071        BoundingXYVisitor v = new BoundingXYVisitor();
    7172        if (mode.equals("data")) {
    72             for (Layer l : Main.map.mapView.getAllLayers())
     73            for (Layer l : Main.map.mapView.getAllLayers()) {
    7374                l.visitBoundingBox(v);
    74         } else if (mode.equals("layer"))
     75            }
     76        } else if (mode.equals("layer")) {
    7577            Main.map.mapView.getActiveLayer().visitBoundingBox(v);
    76         else if (mode.equals("selection") || mode.equals("conflict")) {
    77             Collection<OsmPrimitive> sel = mode.equals("selection") ? Main.ds.getSelected()
    78                     : Main.map.conflictDialog.conflicts.keySet();
     78        } else if (mode.equals("selection") || mode.equals("conflict")) {
     79            Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>();
     80            if (mode.equals("selection")) {
     81                sel = Main.ds.getSelected();
     82            } else if (mode.equals("conflict")) {
     83                if (Main.map.conflictDialog.getConflicts() != null) {
     84                    sel = Main.map.conflictDialog.getConflicts().getMyConflictParties();
     85                }
     86            }
    7987            if (sel.isEmpty()) {
    8088                JOptionPane.showMessageDialog(Main.parent,
     
    8290                return null;
    8391            }
    84             for (OsmPrimitive osm : sel)
     92            for (OsmPrimitive osm : sel) {
    8593                osm.visit(v);
     94            }
    8695            // increase bbox by 0.001 degrees on each side. this is required
    8796            // especially if the bbox contains one single node, but helpful
  • trunk/src/org/openstreetmap/josm/actions/CopyAction.java

    r1592 r1750  
    4848
    4949        Main.pasteBuffer = copyData();
    50         Main.pasteSource = Main.main.editLayer();
     50        Main.pasteSource = Main.main.createOrGetEditLayer();
    5151        Main.main.menu.paste.setEnabled(true); /* now we have a paste buffer we can make paste available */
    5252
  • trunk/src/org/openstreetmap/josm/actions/DeleteAction.java

    r1418 r1750  
    2525
    2626    public void actionPerformed(ActionEvent e) {
    27         if(!Main.map.mapView.isVisibleDrawableLayer())
     27        if(!Main.map.mapView.isActiveLayerVisible())
    2828            return;
    2929        new org.openstreetmap.josm.actions.mapmode.DeleteAction(Main.map)
  • trunk/src/org/openstreetmap/josm/actions/DuplicateAction.java

    r1594 r1750  
    2828
    2929    public void actionPerformed(ActionEvent e) {
    30         PasteAction.pasteData(CopyAction.copyData(), Main.main.editLayer(), e);
     30        PasteAction.pasteData(CopyAction.copyData(), Main.main.createOrGetEditLayer(), e);
    3131    }
    3232
  • trunk/src/org/openstreetmap/josm/actions/GpxExportAction.java

    r1677 r1750  
    6464            return;
    6565
    66         exportGpx(file, this.layer == null ? Main.main.editLayer() : this.layer);
     66        exportGpx(file, this.layer == null ? Main.main.createOrGetEditLayer() : this.layer);
    6767    }
    6868
  • trunk/src/org/openstreetmap/josm/actions/MoveAction.java

    r1640 r1750  
    4646            sc = Shortcut.registerShortcut("core:moveright", tr("Move objects {0}", directiontext), KeyEvent.VK_RIGHT, Shortcut.GROUPS_ALT1+Shortcut.GROUP_DIRECT);
    4747        }
    48         if (text) {
     48        if (text)
    4949            return directiontext;
    50         } else {
     50        else
    5151            return sc;
    52         }
    5352    }
    5453
    5554    public MoveAction(Direction dir) {
    5655        super(tr("Move {0}", calltosupermustbefirststatementinconstructor(dir, true)), null,
    57               tr("Moves Objects {0}", calltosupermustbefirststatementinconstructor(dir, true)),
    58               (Shortcut)calltosupermustbefirststatementinconstructor(dir, false), true);
     56                tr("Moves Objects {0}", calltosupermustbefirststatementinconstructor(dir, true)),
     57                (Shortcut)calltosupermustbefirststatementinconstructor(dir, false), true);
    5958        myDirection = dir;
    6059    }
     
    9291        ? Main.main.undoRedo.commands.getLast() : null;
    9392
    94         if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand)c).objects))
     93        if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand)c).getMovedNodes())) {
    9594            ((MoveCommand)c).moveAgain(distx, disty);
    96         else
     95        } else {
    9796            Main.main.undoRedo.add(
    9897                    c = new MoveCommand(selection, distx, disty));
     98        }
    9999
    100100        for (Node n : affectedNodes) {
  • trunk/src/org/openstreetmap/josm/actions/PasteAction.java

    r1640 r1750  
    6969            Node nnew = new Node(n);
    7070            nnew.id = 0;
    71             if (Main.main.editLayer() == source) {
     71            if (Main.main.createOrGetEditLayer() == source) {
    7272                nnew.setEastNorth(nnew.getEastNorth().add(offsetEast, offsetNorth));
    7373            }
  • trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java

    r1677 r1750  
    2020import org.apache.tools.bzip2.CBZip2OutputStream;
    2121import org.openstreetmap.josm.Main;
     22import org.openstreetmap.josm.data.conflict.ConflictCollection;
    2223import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2324import org.openstreetmap.josm.gui.ExtendedDialog;
     
    4950        Layer layer = this.layer;
    5051        if (layer == null && Main.map != null && (Main.map.mapView.getActiveLayer() instanceof OsmDataLayer
    51                 || Main.map.mapView.getActiveLayer() instanceof GpxLayer))
     52                || Main.map.mapView.getActiveLayer() instanceof GpxLayer)) {
    5253            layer = Main.map.mapView.getActiveLayer();
    53         if (layer == null)
    54             layer = Main.main.editLayer();
     54        }
     55        if (layer == null) {
     56            layer = Main.main.createOrGetEditLayer();
     57        }
    5558
    5659        if (!checkSaveConditions(layer))
     
    8790        }
    8891
    89         if (layer instanceof OsmDataLayer && isDataSetEmpty((OsmDataLayer)layer) && 1 != new ExtendedDialog(Main.parent, tr("Empty document"), tr("The document contains no data."), new String[] {tr("Save anyway"), tr("Cancel")}, new String[] {"save.png", "cancel.png"}).getValue()) {
    90             return false;
    91         }
    92         if (layer instanceof GpxLayer && ((GpxLayer)layer).data == null) {
    93             return false;
    94         }
    95         if (!Main.map.conflictDialog.conflicts.isEmpty()) {
    96             int answer = new ExtendedDialog(Main.parent,
    97                 tr("Conflicts"),
    98                 tr("There are unresolved conflicts. Conflicts will not be saved and handled as if you rejected all. Continue?"),
    99                 new String[] {tr("Reject Conflicts and Save"), tr("Cancel")},
    100                 new String[] {"save.png", "cancel.png"}).getValue();
    101 
    102             if (answer != 1) return false;
     92        if (layer instanceof OsmDataLayer && isDataSetEmpty((OsmDataLayer)layer) && 1 != new ExtendedDialog(Main.parent, tr("Empty document"), tr("The document contains no data."), new String[] {tr("Save anyway"), tr("Cancel")}, new String[] {"save.png", "cancel.png"}).getValue())
     93            return false;
     94        if (layer instanceof GpxLayer && ((GpxLayer)layer).data == null)
     95            return false;
     96        if (layer instanceof OsmDataLayer)  {
     97            ConflictCollection conflicts = ((OsmDataLayer)layer).getConflicts();
     98            if (conflicts != null && !conflicts.isEmpty()) {
     99                int answer = new ExtendedDialog(Main.parent,
     100                        tr("Conflicts"),
     101                        tr("There are unresolved conflicts. Conflicts will not be saved and handled as if you rejected all. Continue?"),
     102                        new String[] {tr("Reject Conflicts and Save"), tr("Cancel")},
     103                        new String[] {"save.png", "cancel.png"}).getValue();
     104
     105                if (answer != 1) return false;
     106            }
    103107        }
    104108        return true;
     
    148152            OsmGzipImporter osmGzipImporter = new OsmGzipImporter();
    149153            OsmBzip2Importer osmBzip2Importer = new OsmBzip2Importer();
    150             if (gpxImExporter.acceptFile(file))
     154            if (gpxImExporter.acceptFile(file)) {
    151155                GpxExportAction.exportGpx(file, layer);
    152             else if (osmImExporter.acceptFile(file)
     156            } else if (osmImExporter.acceptFile(file)
    153157                    || osmGzipImporter.acceptFile(file)
    154158                    || osmBzip2Importer.acceptFile(file))
     
    180184                w.close();
    181185                // FIXME - how to close?
    182                 if (!Main.pref.getBoolean("save.keepbackup") && (tmpFile != null))
     186                if (!Main.pref.getBoolean("save.keepbackup") && (tmpFile != null)) {
    183187                    tmpFile.delete();
     188                }
    184189            } else {
    185190                JOptionPane.showMessageDialog(Main.parent, tr("Unknown file extension."));
  • trunk/src/org/openstreetmap/josm/actions/UpdateDataAction.java

    r1670 r1750  
    3232        int bboxCount = 0;
    3333        List<Area> areas = new ArrayList<Area>();
    34         for(DataSource ds : Main.main.editLayer().data.dataSources) {
     34        for(DataSource ds : Main.main.createOrGetEditLayer().data.dataSources) {
    3535            areas.add(new Area(ds.bounds.asRect()));
    3636        }
  • trunk/src/org/openstreetmap/josm/actions/UpdateSelectionAction.java

    r1690 r1750  
    3535    protected void handlePrimitiveGoneException(long id) {
    3636        MultiFetchServerObjectReader reader = new MultiFetchServerObjectReader();
    37         reader.append(Main.main.editLayer().data,id);
     37        reader.append(Main.main.createOrGetEditLayer().data,id);
    3838        DataSet ds = null;
    3939        try {
     
    4343            return;
    4444        }
    45         Main.main.editLayer().mergeFrom(ds);
     45        Main.main.createOrGetEditLayer().mergeFrom(ds);
    4646    }
    4747
     
    9090            return;
    9191        }
    92         Main.main.editLayer().mergeFrom(ds);
     92        Main.main.createOrGetEditLayer().mergeFrom(ds);
    9393    }
    9494
    9595    public void updatePrimitive(long id) {
    96         OsmPrimitive primitive = Main.main.editLayer().data.getPrimitiveById(id);
     96        OsmPrimitive primitive = Main.main.createOrGetEditLayer().data.getPrimitiveById(id);
    9797        Set<OsmPrimitive> s = new HashSet<OsmPrimitive>();
    9898        s.add(primitive);
  • trunk/src/org/openstreetmap/josm/actions/UploadAction.java

    r1698 r1750  
    2323
    2424import org.openstreetmap.josm.Main;
     25import org.openstreetmap.josm.data.conflict.ConflictCollection;
    2526import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2627import org.openstreetmap.josm.gui.ExtendedDialog;
     
    159160        }
    160161
    161         if (!Main.map.conflictDialog.conflicts.isEmpty()) {
     162        ConflictCollection conflicts = Main.main.createOrGetEditLayer().getConflicts();
     163        if (conflicts !=null && !conflicts.isEmpty()) {
    162164            JOptionPane.showMessageDialog(Main.parent,tr("There are unresolved conflicts. You have to resolve these first."));
    163165            Main.map.conflictDialog.action.button.setSelected(true);
     
    212214                try {
    213215                    server.uploadOsm(Main.ds.version, all);
    214                     Main.main.editLayer().cleanData(server.processed, !add.isEmpty());
     216                    Main.main.createOrGetEditLayer().cleanData(server.processed, !add.isEmpty());
    215217                } catch (Exception sxe) {
    216218                    if (uploadCancelled) {
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTask.java

    r1670 r1750  
    3939        private DataSet dataSet;
    4040        private boolean newLayer;
    41         private int num = 1;
    4241        private String msg = "";
    4342
     
    6968            }
    7069            rememberDownloadedData(dataSet);
    71             OsmDataLayer layer = new OsmDataLayer(dataSet, tr("Data Layer {0}", num), null);
     70            OsmDataLayer layer = new OsmDataLayer(dataSet, OsmDataLayer.createNewName(), null);
    7271            if (newLayer) {
    7372                Main.main.addLayer(layer);
    7473            } else {
    75                 Main.main.editLayer().mergeFrom(layer);
     74                Main.main.createOrGetEditLayer().mergeFrom(layer);
    7675            }
    7776
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTaskList.java

    r1690 r1750  
    4242    public void download(boolean newLayer, List<Rectangle2D> rects) {
    4343        if(newLayer) {
    44             Layer l = new OsmDataLayer(new DataSet(), tr("Data Layer"), null);
     44            Layer l = new OsmDataLayer(new DataSet(), OsmDataLayer.createNewName(), null);
    4545            Main.main.addLayer(l);
    4646            Main.map.mapView.setActiveLayer(l);
     
    9898        }
    9999
    100         Set<Long> myPrimitiveIds = Main.main.editLayer().data.getPrimitiveIds();
     100        Set<Long> myPrimitiveIds = Main.main.createOrGetEditLayer().data.getPrimitiveIds();
    101101        Set<Long> downloadedIds = getDownloadedIds();
    102102        myPrimitiveIds.removeAll(downloadedIds);
     
    108108
    109109    protected void checkPotentiallyDeletedPrimitives(Set<Long> potentiallyDeleted) {
    110         DataSet ds =  Main.main.editLayer().data;
     110        DataSet ds =  Main.main.createOrGetEditLayer().data;
    111111        ArrayList<OsmPrimitive> toSelect = new ArrayList<OsmPrimitive>();
    112112        for (Long id : potentiallyDeleted) {
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

    r1677 r1750  
    6464    @Override public void actionPerformed(ActionEvent e) {
    6565        super.actionPerformed(e);
    66         if(!Main.map.mapView.isDrawableLayer())
     66        if(!Main.map.mapView.isActiveLayerDrawable())
    6767            return;
    6868        doActionPerformed(e);
     
    7070
    7171    public void doActionPerformed(ActionEvent e) {
    72         if(!Main.map.mapView.isDrawableLayer())
     72        if(!Main.map.mapView.isActiveLayerDrawable())
    7373            return;
    7474        boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
     
    9696        if (e.getButton() != MouseEvent.BUTTON1)
    9797            return;
    98         if(!Main.map.mapView.isVisibleDrawableLayer())
     98        if(!Main.map.mapView.isActiveLayerVisible())
    9999            return;
    100100        boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r1725 r1750  
    240240     */
    241241    public void eventDispatched(AWTEvent event) {
    242         if(Main.map == null || Main.map.mapView == null || !Main.map.mapView.isDrawableLayer())
     242        if(Main.map == null || Main.map.mapView == null || !Main.map.mapView.isActiveLayerDrawable())
    243243            return;
    244244        updateKeyModifiers((InputEvent) event);
     
    251251     */
    252252    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    253         if(!Main.map.mapView.isDrawableLayer())
     253        if(!Main.map.mapView.isActiveLayerDrawable())
    254254            return;
    255255        computeHelperLine();
     
    288288        if (e.getButton() != MouseEvent.BUTTON1)
    289289            return;
    290         if(!Main.map.mapView.isDrawableLayer())
     290        if(!Main.map.mapView.isActiveLayerDrawable())
    291291            return;
    292292
     
    576576
    577577    @Override public void mouseMoved(MouseEvent e) {
    578         if(!Main.map.mapView.isDrawableLayer())
     578        if(!Main.map.mapView.isActiveLayerDrawable())
    579579            return;
    580580
     
    705705     */
    706706    @Override public void mouseExited(MouseEvent e) {
    707         if(!Main.map.mapView.isDrawableLayer())
     707        if(!Main.map.mapView.isActiveLayerDrawable())
    708708            return;
    709709        mousePos = e.getPoint();
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

    r1677 r1750  
    126126     */
    127127    @Override public void mouseDragged(MouseEvent e) {
    128         if(!Main.map.mapView.isVisibleDrawableLayer())
     128        if(!Main.map.mapView.isActiveLayerVisible())
    129129            return;
    130130        if (mode == Mode.select) return;
     
    195195     */
    196196    @Override public void mousePressed(MouseEvent e) {
    197         if(!Main.map.mapView.isVisibleDrawableLayer())
     197        if(!Main.map.mapView.isActiveLayerVisible())
    198198            return;
    199199        if (!(Boolean)this.getValue("active")) return;
     
    227227     */
    228228    @Override public void mouseReleased(MouseEvent e) {
    229         if(!Main.map.mapView.isVisibleDrawableLayer())
     229        if(!Main.map.mapView.isActiveLayerVisible())
    230230            return;
    231231        restoreCursor();
  • trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

    r1725 r1750  
    9696    public SelectAction(MapFrame mapFrame) {
    9797        super(tr("Select"), "move/move", tr("Select, move and rotate objects"),
    98             Shortcut.registerShortcut("mapmode:select", tr("Mode: {0}", tr("Select")), KeyEvent.VK_S, Shortcut.GROUP_EDIT),
    99             mapFrame,
    100             getCursor("normal", "selection", Cursor.DEFAULT_CURSOR));
     98                Shortcut.registerShortcut("mapmode:select", tr("Mode: {0}", tr("Select")), KeyEvent.VK_S, Shortcut.GROUP_EDIT),
     99                mapFrame,
     100                getCursor("normal", "selection", Cursor.DEFAULT_CURSOR));
    101101        putValue("help", "Action/Move/Move");
    102102        selectionManager = new SelectionManager(this, false, mapFrame.mapView);
     
    131131        Main.map.mapView.addMouseListener(this);
    132132        Main.map.mapView.addMouseMotionListener(this);
    133         Main.map.mapView.enableVirtualNodes(
    134         Main.pref.getInteger("mappaint.node.virtual-size", 8) != 0);
     133        Main.map.mapView.setVirtualNodesEnabled(
     134                Main.pref.getInteger("mappaint.node.virtual-size", 8) != 0);
    135135    }
    136136
     
    140140        Main.map.mapView.removeMouseListener(this);
    141141        Main.map.mapView.removeMouseMotionListener(this);
    142         Main.map.mapView.enableVirtualNodes(false);
     142        Main.map.mapView.setVirtualNodesEnabled(false);
    143143    }
    144144
     
    149149     */
    150150    @Override public void mouseDragged(MouseEvent e) {
    151         if(!Main.map.mapView.isVisibleDrawableLayer())
     151        if(!Main.map.mapView.isActiveLayerVisible())
    152152            return;
    153153
     
    162162                return;
    163163
    164         if (mode == Mode.move)
     164        if (mode == Mode.move) {
    165165            setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
     166        }
    166167
    167168        if (mousePos == null) {
     
    196197            virtualCmds.add(new MoveCommand(virtualNode, dx, dy));
    197198            String text = trn("Add and move a virtual new node to way",
    198             "Add and move a virtual new node to {0} ways", virtualWays.size(),
    199             virtualWays.size());
     199                    "Add and move a virtual new node to {0} ways", virtualWays.size(),
     200                    virtualWays.size());
    200201
    201202            Main.main.undoRedo.add(new SequenceCommand(text, virtualCmds));
     
    214215
    215216            Command c = !Main.main.undoRedo.commands.isEmpty()
    216                 ? Main.main.undoRedo.commands.getLast() : null;
    217             if (c instanceof SequenceCommand)
     217            ? Main.main.undoRedo.commands.getLast() : null;
     218            if (c instanceof SequenceCommand) {
    218219                c = ((SequenceCommand)c).getLastCommand();
     220            }
    219221
    220222            if (mode == Mode.move) {
    221                 if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand)c).objects))
     223                if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand)c).getMovedNodes())) {
    222224                    ((MoveCommand)c).moveAgain(dx,dy);
    223                 else
     225                } else {
    224226                    Main.main.undoRedo.add(
    225                         c = new MoveCommand(selection, dx, dy));
     227                            c = new MoveCommand(selection, dx, dy));
     228                }
    226229
    227230                for (Node n : affectedNodes) {
     
    231234
    232235                        JOptionPane.showMessageDialog(Main.parent,
    233                             tr("Cannot move objects outside of the world."));
     236                                tr("Cannot move objects outside of the world."));
    234237                        restoreCursor();
    235238                        return;
     
    237240                }
    238241            } else if (mode == Mode.rotate) {
    239                 if (c instanceof RotateCommand && affectedNodes.equals(((RotateCommand)c).objects))
     242                if (c instanceof RotateCommand && affectedNodes.equals(((RotateCommand)c).getRotatedNodes())) {
    240243                    ((RotateCommand)c).rotateAgain(mouseStartEN, mouseEN);
    241                 else
     244                } else {
    242245                    Main.main.undoRedo.add(new RotateCommand(selection, mouseStartEN, mouseEN));
     246                }
    243247            }
    244248        }
     
    255259     */
    256260    @Override public void mouseMoved(MouseEvent e) {
    257         if (needMouseMove && mode == Mode.rotate)
     261        if (needMouseMove && mode == Mode.rotate) {
    258262            mouseDragged(e);
     263        }
    259264    }
    260265
     
    271276        {
    272277            Collection<WaySegment> nearestWaySegs = allSegements
    273                  ? c.getNearestWaySegments(p)
    274                  : Collections.singleton(c.getNearestWaySegment(p));
     278            ? c.getNearestWaySegments(p)
     279                    : Collections.singleton(c.getNearestWaySegment(p));
    275280
    276281            for(WaySegment nearestWS : nearestWaySegs) {
    277                 if (nearestWS == null)
     282                if (nearestWS == null) {
    278283                    continue;
     284                }
    279285
    280286                osm = nearestWS.way;
     
    294300                            if(virtualWayNode != null) {
    295301                                if(  !w.nodes.get(nearestWS.lowerIndex+1).equals(virtualWayNode)
    296                                   && !w.nodes.get(nearestWS.lowerIndex  ).equals(virtualWayNode))
     302                                        && !w.nodes.get(nearestWS.lowerIndex  ).equals(virtualWayNode)) {
    297303                                    continue;
    298                             } else
     304                                }
     305                            } else {
    299306                                virtualWayNode = w.nodes.get(nearestWS.lowerIndex+1);
     307                            }
    300308
    301309                            virtualWays.add(nearestWS);
    302                             if(virtualNode == null)
     310                            if(virtualNode == null) {
    303311                                virtualNode = new Node(Main.map.mapView.getLatLon(pc.x, pc.y));
     312                            }
    304313                        }
    305314                    }
     
    322331     */
    323332    @Override public void mousePressed(MouseEvent e) {
    324         if(!Main.map.mapView.isVisibleDrawableLayer())
     333        if(!Main.map.mapView.isActiveLayerVisible())
    325334            return;
    326335
     
    335344        // We don't want to change to draw tool if the user tries to (de)select
    336345        // stuff but accidentally clicks in an empty area when selection is empty
    337         if(shift || ctrl)
     346        if(shift || ctrl) {
    338347            cancelDrawMode = true;
     348        }
    339349
    340350        mouseDownTime = System.currentTimeMillis();
     
    345355
    346356        if (ctrl && shift) {
    347             if (Main.ds.getSelected().isEmpty()) selectPrims(osmColl, true, false, false, false);
     357            if (Main.ds.getSelected().isEmpty()) {
     358                selectPrims(osmColl, true, false, false, false);
     359            }
    348360            mode = Mode.rotate;
    349361            setCursor(ImageProvider.getCursor("rotate", null));
     
    354366            // move.
    355367            selectPrims(osmColl,
    356                 shift || Main.ds.getSelected().containsAll(osmColl),
    357                 ctrl, false, false);
     368                    shift || Main.ds.getSelected().containsAll(osmColl),
     369                    ctrl, false, false);
    358370            mode = Mode.move;
    359371        } else {
     
    373385        // Mode.move   redraws when mouseDragged is called
    374386        // Mode.rotate redraws here
    375         if(mode == Mode.rotate)
     387        if(mode == Mode.rotate) {
    376388            Main.map.mapView.repaint();
     389        }
    377390
    378391        mousePos = e.getPoint();
     
    383396     */
    384397    @Override public void mouseReleased(MouseEvent e) {
    385         if(!Main.map.mapView.isVisibleDrawableLayer())
     398        if(!Main.map.mapView.isActiveLayerVisible())
    386399            return;
    387400
     
    402415            if (!didMove) {
    403416                selectPrims(
    404                     Main.map.mapView.getNearestCollection(e.getPoint()),
    405                     shift, ctrl, true, false);
     417                        Main.map.mapView.getNearestCollection(e.getPoint()),
     418                        shift, ctrl, true, false);
    406419
    407420                // If the user double-clicked a node, change to draw mode
     
    423436                for (OsmPrimitive osm : selection)
    424437                {
    425                     if(osm instanceof Node)
     438                    if(osm instanceof Node) {
    426439                        s.add(osm);
    427                     else if(osm instanceof Way)
     440                    } else if(osm instanceof Way)
    428441                    {
    429442                        s.add(osm);
     
    433446                    {
    434447                        if(1 != new ExtendedDialog(Main.parent, tr("Move elements"),
    435                         tr("You did move more than {0} elements. "
    436                         + "Moving a large number of elements is often an error.\n"
    437                         + "Really move them?", max),
    438                         new String[] {tr("Move them"), tr("Undo move")},
    439                         new String[] {"reorder.png", "cancel.png"}).getValue())
     448                                tr("You did move more than {0} elements. "
     449                                        + "Moving a large number of elements is often an error.\n"
     450                                        + "Really move them?", max),
     451                                        new String[] {tr("Move them"), tr("Undo move")},
     452                                        new String[] {"reorder.png", "cancel.png"}).getValue())
    440453                        {
    441454                            Main.main.undoRedo.undo();
     
    451464                        LinkedList<Node> selNodes = new LinkedList<Node>();
    452465                        for (OsmPrimitive osm : selection)
    453                             if (osm instanceof Node)
     466                            if (osm instanceof Node) {
    454467                                selNodes.add((Node)osm);
     468                            }
    455469                        if (selNodes.size() > 0) {
    456470                            selNodes.add(n);
     
    474488
    475489    public void selectPrims(Collection<OsmPrimitive> selectionList, boolean shift,
    476     boolean ctrl, boolean released, boolean area) {
     490            boolean ctrl, boolean released, boolean area) {
    477491        if ((shift && ctrl) || (ctrl && !released))
    478492            return; // not allowed together
    479493
    480494        Collection<OsmPrimitive> curSel;
    481         if (!ctrl && !shift)
     495        if (!ctrl && !shift) {
    482496            curSel = new LinkedList<OsmPrimitive>(); // new selection will replace the old.
    483         else
     497        } else {
    484498            curSel = Main.ds.getSelected();
     499        }
    485500
    486501        for (OsmPrimitive osm : selectionList)
     
    488503            if (ctrl)
    489504            {
    490                 if(curSel.contains(osm))
     505                if(curSel.contains(osm)) {
    491506                    curSel.remove(osm);
    492                 else if(!area)
     507                } else if(!area) {
    493508                    curSel.add(osm);
    494             }
    495             else
     509                }
     510            } else {
    496511                curSel.add(osm);
     512            }
    497513        }
    498514        Main.ds.setSelected(curSel);
     
    501517
    502518    @Override public String getModeHelpText() {
    503         if (mode == Mode.select) {
     519        if (mode == Mode.select)
    504520            return tr("Release the mouse button to select the objects in the rectangle.");
    505         } else if (mode == Mode.move) {
     521        else if (mode == Mode.move)
    506522            return tr("Release the mouse button to stop moving. Ctrl to merge with nearest node.");
    507         } else if (mode == Mode.rotate) {
     523        else if (mode == Mode.rotate)
    508524            return tr("Release the mouse button to stop rotating.");
    509         } else {
     525        else
    510526            return tr("Move objects by dragging; Shift to add to selection (Ctrl to toggle); Shift-Ctrl to rotate selected; or change selection");
    511         }
    512527    }
    513528
  • trunk/src/org/openstreetmap/josm/command/AddCommand.java

    r1169 r1750  
    1010import javax.swing.tree.MutableTreeNode;
    1111
    12 import org.openstreetmap.josm.Main;
    13 import org.openstreetmap.josm.data.osm.DataSet;
    1412import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1513import org.openstreetmap.josm.data.osm.visitor.AddVisitor;
    1614import org.openstreetmap.josm.data.osm.visitor.DeleteVisitor;
    1715import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
    18 import org.openstreetmap.josm.gui.layer.Layer;
    19 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2016
    2117/**
     
    2319 * way.
    2420 *
    25  * See {@link ChangeCommand ChangeCommand} for comments on relation back references.
     21 * See {@see ChangeCommand} for comments on relation back references.
    2622 *
    2723 * @author imi
     
    3430    private final OsmPrimitive osm;
    3531
    36     private DataSet ds;
    37 
    3832    /**
    3933     * Create the command and specify the element to add.
    4034     */
    4135    public AddCommand(OsmPrimitive osm) {
     36        super();
    4237        this.osm = osm;
    43         this.ds = Main.main.editLayer().data;
    4438    }
    4539
    4640    @Override public boolean executeCommand() {
    47         osm.visit(new AddVisitor(ds));
     41        osm.visit(new AddVisitor(getLayer().data));
    4842        return true;
    4943    }
    5044
    5145    @Override public void undoCommand() {
    52         osm.visit(new DeleteVisitor(ds));
     46        osm.visit(new DeleteVisitor(getLayer().data));
    5347    }
    5448
     
    5751    }
    5852
    59     // faster implementation
    60     @Override public boolean invalidBecauselayerRemoved(Layer oldLayer) {
    61         return oldLayer instanceof OsmDataLayer && ((OsmDataLayer)oldLayer).data == ds;
    62     }
    63 
    6453    @Override public MutableTreeNode description() {
    6554        NameVisitor v = new NameVisitor();
    6655        osm.visit(v);
    67         return new DefaultMutableTreeNode(new JLabel(tr("Add")+" "+tr(v.className)+" "+v.name, v.icon, JLabel.HORIZONTAL));
     56        return new DefaultMutableTreeNode(
     57                new JLabel(tr("Add {0} {1}", tr(v.className), v.name), v.icon, JLabel.HORIZONTAL));
    6858    }
    6959}
  • trunk/src/org/openstreetmap/josm/command/ChangeCommand.java

    r1169 r1750  
    2525
    2626    public ChangeCommand(OsmPrimitive osm, OsmPrimitive newOsm) {
     27        super();
    2728        this.osm = osm;
    2829        this.newOsm = newOsm;
     
    4344        NameVisitor v = new NameVisitor();
    4445        osm.visit(v);
    45         return new DefaultMutableTreeNode(new JLabel(tr("Change")+" "+tr(v.className)+" "+v.name, v.icon, JLabel.HORIZONTAL));
     46        return new DefaultMutableTreeNode(new JLabel(tr("Change {0} {1}", tr(v.className), v.name), v.icon, JLabel.HORIZONTAL));
    4647    }
    4748}
  • trunk/src/org/openstreetmap/josm/command/ChangePropertyCommand.java

    r1347 r1750  
    4040
    4141    public ChangePropertyCommand(Collection<? extends OsmPrimitive> objects, String key, String value) {
     42        super();
    4243        this.objects = new LinkedList<OsmPrimitive>();
    4344        this.key = key;
     
    4546        if (value == null) {
    4647            for (OsmPrimitive osm : objects) {
    47                 if(osm.get(key) != null)
     48                if(osm.get(key) != null) {
    4849                    this.objects.add(osm);
     50                }
    4951            }
    5052        } else {
     
    6466        String val = object.get(key);
    6567        if ((value == null && val != null)
    66         || (value != null && (val == null || !value.equals(val))))
     68                || (value != null && (val == null || !value.equals(val)))) {
    6769            this.objects.add(object);
     70        }
    6871    }
    6972
     
    9598            text = value == null
    9699            ? tr("Remove \"{0}\" for {1} ''{2}''", key, tr(v.className), v.name)
    97             : tr("Set {0}={1} for {2} ''{3}''",key,value, tr(v.className), v.name);
     100                    : tr("Set {0}={1} for {2} ''{3}''",key,value, tr(v.className), v.name);
    98101        }
    99102        else
     
    101104            text = value == null
    102105            ? tr("Remove \"{0}\" for {1} {2}", key, objects.size(), trn("object","objects",objects.size()))
    103             : tr("Set {0}={1} for {2} {3}",key,value, objects.size(), trn("object","objects",objects.size()));
     106                    : tr("Set {0}={1} for {2} {3}",key,value, objects.size(), trn("object","objects",objects.size()));
    104107        }
    105108        DefaultMutableTreeNode root = new DefaultMutableTreeNode(new JLabel(text, ImageProvider.get("data", "key"), JLabel.HORIZONTAL));
  • trunk/src/org/openstreetmap/josm/command/ChangeRelationMemberRoleCommand.java

    r1617 r1750  
    1313import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1414import org.openstreetmap.josm.data.osm.Relation;
    15 import org.openstreetmap.josm.data.osm.RelationMember;
    16 
    1715import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
    1816
     
    3634
    3735    public ChangeRelationMemberRoleCommand(Relation relation, int position, String newRole) {
     36        super();
    3837        this.relation = relation;
    3938        this.position = position;
     
    6766        NameVisitor v = new NameVisitor();
    6867        relation.visit(v);
    69         return new DefaultMutableTreeNode(new JLabel(tr("ChangeRelationMemberRole")+" "+tr(v.className)+" "+v.name, v.icon, JLabel.HORIZONTAL));
     68        return new DefaultMutableTreeNode(new JLabel(tr("ChangeRelationMemberRole {0} {1}", tr(v.className), v.name), v.icon, JLabel.HORIZONTAL));
    7069    }
    7170}
  • trunk/src/org/openstreetmap/josm/command/Command.java

    r1523 r1750  
    1111
    1212import org.openstreetmap.josm.Main;
    13 import org.openstreetmap.josm.data.osm.DataSet;
    1413import org.openstreetmap.josm.data.osm.Node;
    1514import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2524 * one atomic action on a specific dataset, such as move or delete.
    2625 *
    27  * Remember that the command must be executable and undoable, even if the
    28  * Main.ds has changed, so the command must save the dataset it operates on
    29  * if necessary.
    30  *
     26 * The command remembers the {@see OsmDataLayer} it is operating on.
     27 *
    3128 * @author imi
    3229 */
    3330abstract public class Command {
    3431
    35    private static final class CloneVisitor extends AbstractVisitor {
    36       public Map<OsmPrimitive, OsmPrimitive> orig = new HashMap<OsmPrimitive, OsmPrimitive>();
     32    private static final class CloneVisitor extends AbstractVisitor {
     33        public Map<OsmPrimitive, OsmPrimitive> orig = new HashMap<OsmPrimitive, OsmPrimitive>();
    3734
    38       public void visit(Node n) {
    39          orig.put(n, new Node(n));
    40       }
    41       public void visit(Way w) {
    42          orig.put(w, new Way(w));
    43       }
    44       public void visit(Relation e) {
    45          orig.put(e, new Relation(e));
    46       }
    47    }
     35        public void visit(Node n) {
     36            orig.put(n, new Node(n));
     37        }
     38        public void visit(Way w) {
     39            orig.put(w, new Way(w));
     40        }
     41        public void visit(Relation e) {
     42            orig.put(e, new Relation(e));
     43        }
     44    }
    4845
    49    private CloneVisitor orig;
     46    /** the map of OsmPrimitives in the original state to OsmPrimitives in cloned state */
     47    private Map<OsmPrimitive, OsmPrimitive> cloneMap = new HashMap<OsmPrimitive, OsmPrimitive>();
    5048
    51    protected DataSet ds;
     49    /** the layer which this command is applied to */
     50    private OsmDataLayer layer;
    5251
    53    public Command() {
    54       this.ds = Main.main.editLayer().data;
    55    }
    56    /**
    57     * Executes the command on the dataset. This implementation will remember all
    58     * primitives returned by fillModifiedData for restoring them on undo.
    59     */
    60    public boolean did_execute = false;
    61    public boolean executeCommand() {
    62       did_execute = true;
    63       orig = new CloneVisitor();
    64       Collection<OsmPrimitive> all = new HashSet<OsmPrimitive>();
    65       fillModifiedData(all, all, all);
    66       for (OsmPrimitive osm : all)
    67          osm.visit(orig);
    68       return true;
    69    }
     52    public Command() {
     53        this.layer = Main.main.map.mapView.getEditLayer();
     54    }
     55    /**
     56     * Executes the command on the dataset. This implementation will remember all
     57     * primitives returned by fillModifiedData for restoring them on undo.
     58     */
     59    public boolean executeCommand() {
     60        CloneVisitor visitor = new CloneVisitor();
     61        Collection<OsmPrimitive> all = new HashSet<OsmPrimitive>();
     62        fillModifiedData(all, all, all);
     63        for (OsmPrimitive osm : all) {
     64            osm.visit(visitor);
     65        }
     66        cloneMap = visitor.orig;
     67        return true;
     68    }
    7069
    71    /**
    72     * Undoes the command.
    73     * It can be assumed that all objects are in the same state they were before.
    74     * It can also be assumed that executeCommand was called exactly once before.
    75     *
    76     * This implementation undoes all objects stored by a former call to executeCommand.
    77     */
    78    public void undoCommand() {
    79       for (Entry<OsmPrimitive, OsmPrimitive> e : orig.orig.entrySet())
    80          e.getKey().cloneFrom(e.getValue());
    81    }
     70    /**
     71     * Undoes the command.
     72     * It can be assumed that all objects are in the same state they were before.
     73     * It can also be assumed that executeCommand was called exactly once before.
     74     *
     75     * This implementation undoes all objects stored by a former call to executeCommand.
     76     */
     77    public void undoCommand() {
     78        for (Entry<OsmPrimitive, OsmPrimitive> e : cloneMap.entrySet()) {
     79            e.getKey().cloneFrom(e.getValue());
     80        }
     81    }
    8282
    83    /**
    84     * Called when a layer has been removed to have the command remove itself from
    85     * any buffer if it is not longer applicable to the dataset (e.g. it was part of
    86     * the removed layer)
    87     */
    88    public boolean invalidBecauselayerRemoved(Layer oldLayer) {
    89       if (!(oldLayer instanceof OsmDataLayer))
    90          return false;
    91       HashSet<OsmPrimitive> modified = new HashSet<OsmPrimitive>();
    92       fillModifiedData(modified, modified, modified);
    93       if (modified.isEmpty())
    94          return false;
    95 
    96       HashSet<OsmPrimitive> all = new HashSet<OsmPrimitive>(((OsmDataLayer)oldLayer).data.allPrimitives());
    97       for (OsmPrimitive osm : all)
    98          if (all.contains(osm))
    99                  return true;
    100 
    101       return false;
    102    }
     83    /**
     84     * Called when a layer has been removed to have the command remove itself from
     85     * any buffer if it is not longer applicable to the dataset (e.g. it was part of
     86     * the removed layer)
     87     *
     88     * @param oldLayer the old layer
     89     * @return true if this command
     90     */
     91    public boolean invalidBecauselayerRemoved(Layer oldLayer) {
     92        if (!(oldLayer instanceof OsmDataLayer))
     93            return false;
     94        return layer == oldLayer;
     95    }
    10396
    10497    /**
     
    107100     */
    108101    public OsmPrimitive getOrig(OsmPrimitive osm) {
    109         OsmPrimitive o = orig.orig.get(osm);
     102        OsmPrimitive o = cloneMap.get(osm);
    110103        if (o != null)
    111              return o;
     104            return o;
    112105        Main.debug("unable to find osm with id: " + osm.id + " hashCode: " + osm.hashCode());
    113         for (OsmPrimitive t : orig.orig.keySet()) {
    114              OsmPrimitive to = orig.orig.get(t);
    115              Main.debug("now: " + t.id + " hashCode: " + t.hashCode());
    116              Main.debug("orig: " + to.id + " hashCode: " + to.hashCode());
     106        for (OsmPrimitive t : cloneMap.keySet()) {
     107            OsmPrimitive to = cloneMap.get(t);
     108            Main.debug("now: " + t.id + " hashCode: " + t.hashCode());
     109            Main.debug("orig: " + to.id + " hashCode: " + to.hashCode());
    117110        }
    118111        return o;
    119112    }
    120113
    121    /**
    122     * Fill in the changed data this command operates on.
    123     * Add to the lists, don't clear them.
    124     *
    125     * @param modified The modified primitives
    126     * @param deleted The deleted primitives
    127     * @param added The added primitives
    128     */
    129    abstract public void fillModifiedData(Collection<OsmPrimitive> modified,
    130          Collection<OsmPrimitive> deleted,
    131          Collection<OsmPrimitive> added);
     114    /**
     115     * Replies the layer this command is (or was) applied to.
     116     *
     117     * @return
     118     */
     119    protected  OsmDataLayer getLayer() {
     120        return layer;
     121    }
    132122
    133    abstract public MutableTreeNode description();
     123    /**
     124     * Fill in the changed data this command operates on.
     125     * Add to the lists, don't clear them.
     126     *
     127     * @param modified The modified primitives
     128     * @param deleted The deleted primitives
     129     * @param added The added primitives
     130     */
     131    abstract public void fillModifiedData(Collection<OsmPrimitive> modified,
     132            Collection<OsmPrimitive> deleted,
     133            Collection<OsmPrimitive> added);
     134
     135    abstract public MutableTreeNode description();
     136
     137
     138
    134139}
  • trunk/src/org/openstreetmap/josm/command/CoordinateConflictResolveCommand.java

    r1670 r1750  
    1010import javax.swing.tree.MutableTreeNode;
    1111
    12 import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.data.conflict.Conflict;
    1313import org.openstreetmap.josm.data.osm.Node;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
    15 import org.openstreetmap.josm.data.osm.Relation;
    16 import org.openstreetmap.josm.data.osm.Way;
    1715import org.openstreetmap.josm.gui.conflict.MergeDecisionType;
    1816import org.openstreetmap.josm.tools.ImageProvider;
     
    2220 *
    2321 */
    24 public class CoordinateConflictResolveCommand extends Command {
     22public class CoordinateConflictResolveCommand extends ConflictResolveCommand {
    2523
    26     /** my node (in the local dataset). merge decisions are applied to this
    27      *  node
    28      */
    29     private final Node my;
    30     /** their node (in the server dataset) */
    31     private final Node their;
     24    /** the conflict to resolve */
     25    private Conflict<Node> conflict;
    3226
    3327    /** the merge decision */
     
    4236     */
    4337    public CoordinateConflictResolveCommand(Node my, Node their, MergeDecisionType decision) {
    44         this.my = my;
    45         this.their = their;
     38        this.conflict = new Conflict<Node>(my,their);
    4639        this.decision = decision;
    4740    }
     
    5245        return new DefaultMutableTreeNode(
    5346                new JLabel(
    54                         tr("Resolve conflicts in coordinates in {0}",my.id),
     47                        tr("Resolve conflicts in coordinates in {0}",conflict.getMy().id),
    5548                        ImageProvider.get("data", "object"),
    5649                        JLabel.HORIZONTAL
     
    6962            // do nothing
    7063        } else if (decision.equals(MergeDecisionType.KEEP_THEIR)) {
     64            Node my = conflict.getMy();
     65            Node their = conflict.getTheir();
    7166            my.setCoor(their.getCoor());
    7267        } else
    7368            // should not happen
    7469            throw new IllegalStateException(tr("cannot resolve undecided conflict"));
     70
     71        // remember the layer this command was applied to
     72        //
     73        rememberConflict(conflict);
    7574
    7675        return true;
     
    8079    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    8180            Collection<OsmPrimitive> added) {
    82         modified.add(my);
    83     }
    84 
    85     @Override
    86     public void undoCommand() {
    87         // restore former state of modified primitives
    88         //
    89         super.undoCommand();
    90 
    91         // restore a conflict if necessary
    92         //
    93         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    94             Main.map.conflictDialog.addConflict(my, their);
    95         }
     81        modified.add(conflict.getMy());
    9682    }
    9783}
  • trunk/src/org/openstreetmap/josm/command/DeleteCommand.java

    r1656 r1750  
    4242
    4343    /**
    44      * The primitive that get deleted.
    45      */
    46     private final Collection<? extends OsmPrimitive> data;
     44     * The primitives that get deleted.
     45     */
     46    private final Collection<? extends OsmPrimitive> toDelete;
    4747
    4848    /**
     
    5050     */
    5151    public DeleteCommand(Collection<? extends OsmPrimitive> data) {
    52         this.data = data;
     52        super();
     53        this.toDelete = data;
    5354    }
    5455
     
    5859     */
    5960    public DeleteCommand(OsmPrimitive data) {
    60         this.data = Collections.singleton(data);
     61        this.toDelete = Collections.singleton(data);
    6162    }
    6263
    6364    @Override public boolean executeCommand() {
    6465        super.executeCommand();
    65         for (OsmPrimitive osm : data) {
     66        for (OsmPrimitive osm : toDelete) {
    6667            osm.delete(true);
    6768        }
     
    7172    @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    7273            Collection<OsmPrimitive> added) {
    73         deleted.addAll(data);
     74        deleted.addAll(toDelete);
    7475    }
    7576
     
    7778        NameVisitor v = new NameVisitor();
    7879
    79         if (data.size() == 1) {
    80             data.iterator().next().visit(v);
     80        if (toDelete.size() == 1) {
     81            toDelete.iterator().next().visit(v);
    8182            return new DefaultMutableTreeNode(new JLabel(tr("Delete {1} {0}", v.name, tr(v.className)), v.icon,
    8283                    JLabel.HORIZONTAL));
     
    8586        String cname = null;
    8687        String cnamem = null;
    87         for (OsmPrimitive osm : data) {
     88        for (OsmPrimitive osm : toDelete) {
    8889            osm.visit(v);
    8990            if (cname == null) {
     
    9596            }
    9697        }
    97         DefaultMutableTreeNode root = new DefaultMutableTreeNode(new JLabel(tr("Delete {0} {1}", data.size(), trn(
    98                 cname, cnamem, data.size())), ImageProvider.get("data", cname), JLabel.HORIZONTAL));
    99         for (OsmPrimitive osm : data) {
     98        DefaultMutableTreeNode root = new DefaultMutableTreeNode(new JLabel(tr("Delete {0} {1}", toDelete.size(), trn(
     99                cname, cnamem, toDelete.size())), ImageProvider.get("data", cname), JLabel.HORIZONTAL));
     100        for (OsmPrimitive osm : toDelete) {
    100101            osm.visit(v);
    101102            root.add(new DefaultMutableTreeNode(v.toLabel()));
     
    276277            Relation rel = new Relation(cur);
    277278            for (OsmPrimitive osm : relationsToBeChanged.get(cur)) {
    278                 for (RelationMember rm : rel.members) {
    279                     if (rm.member == osm) {
    280                         RelationMember mem = new RelationMember();
    281                         mem.role = rm.role;
    282                         mem.member = rm.member;
    283                         rel.members.remove(mem);
    284                         break;
    285                     }
    286                 }
     279                rel.removeMembersFor(osm);
    287280            }
    288281            cmds.add(new ChangeCommand(cur, rel));
  • trunk/src/org/openstreetmap/josm/command/DeletedStateConflictResolveCommand.java

    r1690 r1750  
    1010import javax.swing.tree.MutableTreeNode;
    1111
    12 import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.data.conflict.Conflict;
    1313import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1414import org.openstreetmap.josm.gui.conflict.MergeDecisionType;
     15import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1516import org.openstreetmap.josm.tools.ImageProvider;
    1617
     
    1920 *
    2021 */
    21 public class DeletedStateConflictResolveCommand extends Command {
     22public class DeletedStateConflictResolveCommand extends ConflictResolveCommand {
    2223
    23     /** my primitive (in the local dataset). merge decisions are applied to this
    24      *  node
    25      */
    26     private final OsmPrimitive my;
    27     /** their primitive (in the server dataset) */
    28     private final OsmPrimitive their;
     24    /** the conflict to resolve */
     25    private Conflict<OsmPrimitive> conflict;
    2926
    3027    /** the merge decision */
    3128    private final MergeDecisionType decision;
    32 
    33 
    3429
    3530    /**
     
    4136     */
    4237    public DeletedStateConflictResolveCommand(OsmPrimitive my, OsmPrimitive their, MergeDecisionType decision) {
    43         this.my = my;
    44         this.their = their;
     38        this.conflict = new Conflict<OsmPrimitive>(my, their);
    4539        this.decision = decision;
    4640    }
     
    5145        return new DefaultMutableTreeNode(
    5246                new JLabel(
    53                         tr("Resolve conflicts in deleted state in {0}",my.id),
     47                        tr("Resolve conflicts in deleted state in {0}",conflict.getMy().id),
    5448                        ImageProvider.get("data", "object"),
    5549                        JLabel.HORIZONTAL
     
    6559        super.executeCommand();
    6660
     61        OsmDataLayer layer = getLayer();
     62
    6763        if (decision.equals(MergeDecisionType.KEEP_MINE)) {
    68             if (my.deleted) {
     64            if (conflict.getMy().deleted) {
    6965                // because my was involved in a conflict it my still be referred
    7066                // to from a way or a relation. Fix this now.
    7167                //
    72                 Main.main.editLayer().data.unlinkReferencesToPrimitive(my);
     68                layer.data.unlinkReferencesToPrimitive(conflict.getMy());
    7369            }
    7470        } else if (decision.equals(MergeDecisionType.KEEP_THEIR)) {
    75             if (their.deleted) {
    76                 Main.main.editLayer().data.unlinkReferencesToPrimitive(my);
    77                 my.delete(true);
     71            if (conflict.getTheir().deleted) {
     72                layer.data.unlinkReferencesToPrimitive(conflict.getMy());
     73                conflict.getMy().delete(true);
    7874            } else {
    79                 my.deleted = their.deleted;
     75                conflict.getMy().deleted = conflict.getTheir().deleted;
    8076            }
    8177        } else
     
    8379            throw new IllegalStateException(tr("cannot resolve undecided conflict"));
    8480
     81        rememberConflict(conflict);
    8582        return true;
    8683    }
     
    8986    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    9087            Collection<OsmPrimitive> added) {
    91         modified.add(my);
    92     }
    93 
    94     @Override
    95     public void undoCommand() {
    96         // restore former state of modified primitives
    97         //
    98         super.undoCommand();
    99 
    100         // restore a conflict if necessary
    101         //
    102         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    103             Main.map.conflictDialog.addConflict(my, their);
    104         }
     88        modified.add(conflict.getMy());
    10589    }
    10690}
  • trunk/src/org/openstreetmap/josm/command/MoveCommand.java

    r1728 r1750  
    1515import javax.swing.tree.MutableTreeNode;
    1616
    17 import org.openstreetmap.josm.data.coor.EastNorth;
    1817import org.openstreetmap.josm.data.coor.LatLon;
    1918import org.openstreetmap.josm.data.osm.Node;
     
    3231     * The objects that should be moved.
    3332     */
    34     public Collection<Node> objects = new LinkedList<Node>();
     33    private Collection<Node> nodes = new LinkedList<Node>();
    3534    /**
    3635     * x difference movement. Coordinates are in northern/eastern
     
    6463     */
    6564    public MoveCommand(Collection<OsmPrimitive> objects, double x, double y) {
     65        super();
    6666        this.x = x;
    6767        this.y = y;
    68         this.objects = AllNodesVisitor.getAllNodes(objects);
    69         for (Node n : this.objects) {
     68        this.nodes = AllNodesVisitor.getAllNodes(objects);
     69        for (Node n : this.nodes) {
    7070            OldState os = new OldState();
    7171            os.latlon = new LatLon(n.getCoor());
     
    8484     */
    8585    public void moveAgain(double x, double y) {
    86         for (Node n : objects) {
     86        for (Node n : nodes) {
    8787            n.setEastNorth(n.getEastNorth().add(x, y));
    8888        }
     
    9292
    9393    @Override public boolean executeCommand() {
    94         for (Node n : objects) {
     94        for (Node n : nodes) {
    9595            n.setEastNorth(n.getEastNorth().add(x, y));
    9696            n.modified = true;
     
    101101    @Override public void undoCommand() {
    102102        Iterator<OldState> it = oldState.iterator();
    103         for (Node n : objects) {
     103        for (Node n : nodes) {
    104104            OldState os = it.next();
    105105            n.setCoor(os.latlon);
     
    109109
    110110    @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    111         for (OsmPrimitive osm : objects)
     111        for (OsmPrimitive osm : nodes) {
    112112            modified.add(osm);
     113        }
    113114    }
    114115
    115116    @Override public MutableTreeNode description() {
    116         return new DefaultMutableTreeNode(new JLabel(tr("Move")+" "+objects.size()+" "+trn("node","nodes",objects.size()), ImageProvider.get("data", "node"), JLabel.HORIZONTAL));
     117        return new DefaultMutableTreeNode(new JLabel(tr("Move")+" "+nodes.size()+" "+trn("node","nodes",nodes.size()), ImageProvider.get("data", "node"), JLabel.HORIZONTAL));
     118    }
     119
     120    public Collection<Node> getMovedNodes() {
     121        return nodes;
    117122    }
    118123}
  • trunk/src/org/openstreetmap/josm/command/PurgePrimitivesCommand.java

    r1690 r1750  
    66import java.util.ArrayList;
    77import java.util.Collection;
    8 import java.util.HashMap;
    98import java.util.List;
    10 import java.util.Map;
     9import java.util.logging.Logger;
    1110
    1211import javax.swing.JLabel;
     
    1514
    1615import org.openstreetmap.josm.Main;
     16import org.openstreetmap.josm.data.conflict.ConflictCollection;
    1717import org.openstreetmap.josm.data.osm.DataSet;
    1818import org.openstreetmap.josm.data.osm.Node;
     
    2121import org.openstreetmap.josm.data.osm.RelationMember;
    2222import org.openstreetmap.josm.data.osm.Way;
     23import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2324import org.openstreetmap.josm.tools.ImageProvider;
    2425
     
    3435 *
    3536 */
    36 public class PurgePrimitivesCommand extends Command{
    37 
     37public class PurgePrimitivesCommand extends ConflictResolveCommand{
     38
     39    static private final Logger logger = Logger.getLogger(PurgePrimitivesCommand.class.getName());
    3840
    3941    /**
     
    144146    private ArrayList<OsmParentChildPair> pairs;
    145147
    146     private Map<OsmPrimitive, OsmPrimitive> resolvedConflicts;
    147148
    148149    /**
     
    154155        purgedPrimitives = new ArrayList<OsmPrimitive>();
    155156        pairs = new ArrayList<OsmParentChildPair>();
    156         resolvedConflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
    157157    }
    158158
     
    219219            purge(toPurge, Main.ds, hive);
    220220            if (toPurge instanceof Node) {
    221                 Main.ds.nodes.remove(toPurge);
     221                getLayer().data.nodes.remove(toPurge);
    222222            } else if (primitive instanceof Way) {
    223                 Main.ds.ways.remove(toPurge);
     223                getLayer().data.ways.remove(toPurge);
    224224            } else if (primitive instanceof Relation) {
    225                 Main.ds.relations.remove(toPurge);
     225                getLayer().data.relations.remove(toPurge);
    226226            }
    227227            purgedPrimitives.add(toPurge);
    228             if (Main.map.conflictDialog.conflicts.containsKey(toPurge)) {
    229                 resolvedConflicts.put(toPurge, Main.map.conflictDialog.conflicts.get(toPurge));
    230                 Main.map.conflictDialog.removeConflictForPrimitive(toPurge);
     228            ConflictCollection conflicts = getLayer().getConflicts();
     229            if (conflicts.hasConflictForMy(toPurge)) {
     230                rememberConflict(conflicts.getConflictForMy(toPurge));
     231                conflicts.remove(toPurge);
    231232            }
    232233        }
     
    246247    @Override
    247248    public void undoCommand() {
     249        if (! Main.map.mapView.hasLayer(getLayer())) {
     250            logger.warning(tr("Can't undo command ''{0}'' because layer ''{1}'' is not present anymore",
     251                    this.toString(),
     252                    getLayer().toString()
     253            ));
     254            return;
     255        }
     256        Main.map.mapView.setActiveLayer(getLayer());
    248257
    249258        // restore purged primitives
    250259        //
    251260        for (OsmPrimitive purged : purgedPrimitives) {
    252             Main.ds.addPrimitive(purged);
    253         }
    254 
    255         // restore conflicts
    256         //
    257         for (OsmPrimitive primitive : resolvedConflicts.keySet()) {
    258             Main.map.conflictDialog.addConflict(primitive, resolvedConflicts.get(primitive));
    259         }
    260 
     261            getLayer().data.addPrimitive(purged);
     262        }
     263        reconstituteConflicts();
    261264        // will restore the former references to the purged nodes
    262265        //
  • trunk/src/org/openstreetmap/josm/command/RelationMemberConflictResolverCommand.java

    r1676 r1750  
    66import java.util.Collection;
    77import java.util.List;
     8import java.util.logging.Logger;
    89
    910import javax.swing.JLabel;
     
    1516import org.openstreetmap.josm.data.osm.Relation;
    1617import org.openstreetmap.josm.data.osm.RelationMember;
     18import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1719import org.openstreetmap.josm.tools.ImageProvider;
    1820
     
    2325 */
    2426public class RelationMemberConflictResolverCommand extends Command {
     27    private static final Logger logger = Logger.getLogger(RelationMemberConflictResolverCommand.class.getName());
    2528
    2629    /** my relation */
     
    3235     */
    3336    private final List<RelationMember> mergedMembers;
     37
     38    /** the layer this conflict is resolved in */
     39    private OsmDataLayer layer;
    3440
    3541    /**
     
    7177            my.members.add(n);
    7278        }
     79
     80        // remember the layer
     81        layer = Main.main.map.mapView.getEditLayer();
    7382        return true;
    7483    }
     
    8291    @Override
    8392    public void undoCommand() {
     93        if (! Main.map.mapView.hasLayer(layer)) {
     94            logger.warning(tr("Can't undo command ''{0}'' because layer ''{1}'' is not present anymore",
     95                    this.toString(),
     96                    layer.toString()
     97            ));
     98            return;
     99        }
     100
     101        Main.map.mapView.setActiveLayer(layer);
     102        OsmDataLayer editLayer = Main.map.mapView.getEditLayer();
     103
    84104        // restore the former state
    85105        //
     
    88108        // restore a conflict if necessary
    89109        //
    90         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    91             Main.map.conflictDialog.conflicts.put(my,their);
     110        if (!editLayer.getConflicts().hasConflictForMy(my)) {
     111            editLayer.getConflicts().add(my,their);
    92112        }
    93113    }
  • trunk/src/org/openstreetmap/josm/command/RemoveRelationMemberCommand.java

    r630 r1750  
    6464        NameVisitor v = new NameVisitor();
    6565        relation.visit(v);
    66         return new DefaultMutableTreeNode(new JLabel(tr("RemoveRelationMember")+" "+tr(v.className)+" "+v.name, v.icon, JLabel.HORIZONTAL));
     66        return new DefaultMutableTreeNode(new JLabel(tr("RemoveRelationMember {0} {1}", tr(v.className), v.name), v.icon, JLabel.HORIZONTAL));
    6767    }
    6868}
  • trunk/src/org/openstreetmap/josm/command/RotateCommand.java

    r1728 r1750  
    3030     * The objects to rotate.
    3131     */
    32     public Collection<Node> objects = new LinkedList<Node>();
     32    private Collection<Node> nodes = new LinkedList<Node>();
    3333
    3434    /**
     
    7070    public RotateCommand(Collection<OsmPrimitive> objects, EastNorth start, EastNorth end) {
    7171
    72         this.objects = AllNodesVisitor.getAllNodes(objects);
     72        this.nodes = AllNodesVisitor.getAllNodes(objects);
    7373        pivot = new EastNorth(0,0);
    7474
    75         for (Node n : this.objects) {
     75        for (Node n : this.nodes) {
    7676            OldState os = new OldState();
    7777            os.latlon = new LatLon(n.getCoor());
     
    8181            pivot = pivot.add(os.eastNorth.east(), os.eastNorth.north());
    8282        }
    83         pivot = new EastNorth(pivot.east()/this.objects.size(), pivot.north()/this.objects.size());
     83        pivot = new EastNorth(pivot.east()/this.nodes.size(), pivot.north()/this.nodes.size());
    8484
    8585        rotationAngle = Math.PI/2;
     
    105105     */
    106106    private void rotateNodes(boolean setModified) {
    107         for (Node n : objects) {
     107        for (Node n : nodes) {
    108108            double cosPhi = Math.cos(rotationAngle);
    109109            double sinPhi = Math.sin(rotationAngle);
     
    114114            double ny = -cosPhi * x + sinPhi * y + pivot.north();
    115115            n.setEastNorth(new EastNorth(nx, ny));
    116             if (setModified)
     116            if (setModified) {
    117117                n.modified = true;
     118            }
    118119        }
    119120    }
     
    125126
    126127    @Override public void undoCommand() {
    127         for (Node n : objects) {
     128        for (Node n : nodes) {
    128129            OldState os = oldState.get(n);
    129130            n.setCoor(os.latlon);
     
    133134
    134135    @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    135         for (OsmPrimitive osm : objects)
     136        for (OsmPrimitive osm : nodes) {
    136137            modified.add(osm);
     138        }
    137139    }
    138140
    139141    @Override public MutableTreeNode description() {
    140         return new DefaultMutableTreeNode(new JLabel(tr("Rotate")+" "+objects.size()+" "+trn("node","nodes",objects.size()), ImageProvider.get("data", "node"), JLabel.HORIZONTAL));
     142        return new DefaultMutableTreeNode(new JLabel(tr("Rotate {0} {1}",nodes.size(),trn("node","nodes",nodes.size())), ImageProvider.get("data", "node"), JLabel.HORIZONTAL));
     143    }
     144
     145    public Collection<Node> getRotatedNodes() {
     146        return nodes;
    141147    }
    142148}
  • trunk/src/org/openstreetmap/josm/command/SequenceCommand.java

    r1169 r1750  
    3333     */
    3434    public SequenceCommand(String name, Collection<Command> sequenz) {
     35        super();
    3536        this.name = name;
    3637        this.sequence = new Command[sequenz.size()];
     
    4546    }
    4647
    47     public int executed_commands = 0;
    4848    @Override public boolean executeCommand() {
    4949        for (int i=0; i < sequence.length; i++) {
    5050            Command c = sequence[i];
    5151            boolean result = c.executeCommand();
    52             if (!result)
     52            if (!result) {
    5353                Main.debug("SequenceCommand, executing command[" + i + "] " +  c + " result: " + result);
     54            }
    5455            if (!result && !continueOnError) {
    5556                this.undoCommands(i-1);
     
    7273        if (!sequence_complete)
    7374            return;
    74         for (int i = start; i >= 0; --i)
     75        for (int i = start; i >= 0; --i) {
    7576            sequence[i].undoCommand();
     77        }
    7678    }
    7779
     
    8183
    8284    @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    83         for (Command c : sequence)
     85        for (Command c : sequence) {
    8486            c.fillModifiedData(modified, deleted, added);
     87        }
    8588    }
    8689
    8790    @Override public MutableTreeNode description() {
    8891        DefaultMutableTreeNode root = new DefaultMutableTreeNode(tr("Sequence")+": "+name);
    89         for (Command c : sequence)
     92        for (Command c : sequence) {
    9093            root.add(c.description());
     94        }
    9195        return root;
    9296    }
  • trunk/src/org/openstreetmap/josm/command/TagConflictResolveCommand.java

    r1670 r1750  
    66import java.util.Collection;
    77import java.util.List;
     8import java.util.logging.Logger;
    89
    910import javax.swing.JLabel;
     
    1112import javax.swing.tree.MutableTreeNode;
    1213
    13 import org.openstreetmap.josm.Main;
    14 import org.openstreetmap.josm.data.osm.Node;
     14import org.openstreetmap.josm.data.conflict.Conflict;
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1616import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    17 import org.openstreetmap.josm.data.osm.Relation;
    18 import org.openstreetmap.josm.data.osm.Way;
    1917import org.openstreetmap.josm.gui.conflict.MergeDecisionType;
    2018import org.openstreetmap.josm.gui.conflict.tags.TagMergeItem;
     
    2523 *
    2624 */
    27 public class TagConflictResolveCommand extends Command {
     25public class TagConflictResolveCommand extends ConflictResolveCommand {
     26    private static final Logger logger = Logger.getLogger(TagConflictResolveCommand.class.getName());
    2827
    29     /** my primitive (in the local dataset). merge decisions are applied to this
    30      *  primitive
    31      */
    32     private final OsmPrimitive my;
    33     /** their primitive (in the server dataset) */
    34     private final OsmPrimitive their;
     28
     29    /** the conflict to resolve */
     30    private Conflict<OsmPrimitive> conflict;
    3531
    3632    /** the list of merge decisions, represented as {@see TagMergeItem}s */
    3733    private final List<TagMergeItem> mergeItems;
     34
    3835
    3936    /**
     
    6057     */
    6158    public TagConflictResolveCommand(OsmPrimitive my, OsmPrimitive their, List<TagMergeItem> mergeItems) {
    62         this.my = my;
    63         this.their = their;
     59        this.conflict = new Conflict<OsmPrimitive>(my,their);
    6460        this.mergeItems = mergeItems;
    6561    }
     
    7066        return new DefaultMutableTreeNode(
    7167                new JLabel(
    72                         tr("Resolve {0} tag conflicts in {1} {2}",getNumDecidedConflicts(), OsmPrimitiveType.from(my).getLocalizedDisplayNameSingular(), my.id),
     68                        tr("Resolve {0} tag conflicts in {1} {2}",getNumDecidedConflicts(), OsmPrimitiveType.from(conflict.getMy()).getLocalizedDisplayNameSingular(), conflict.getMy().id),
    7369                        ImageProvider.get("data", "object"),
    7470                        JLabel.HORIZONTAL
     
    8884        for (TagMergeItem item: mergeItems) {
    8985            if (! item.getMergeDecision().equals(MergeDecisionType.UNDECIDED)) {
    90                 item.applyToMyPrimitive(my);
     86                item.applyToMyPrimitive(conflict.getMy());
    9187            }
    9288        }
     89        rememberConflict(conflict);
    9390        return true;
    9491    }
     
    9794    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    9895            Collection<OsmPrimitive> added) {
    99         modified.add(my);
    100     }
    101 
    102     @Override
    103     public void undoCommand() {
    104         // restore former state of modified primitives
    105         //
    106         super.undoCommand();
    107 
    108         // restore a conflict if necessary
    109         //
    110         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    111             Main.map.conflictDialog.addConflict(my, their);
    112         }
     96        modified.add(conflict.getMy());
    11397    }
    11498}
  • trunk/src/org/openstreetmap/josm/command/UndeletePrimitivesCommand.java

    r1690 r1750  
    66import java.util.ArrayList;
    77import java.util.Collection;
    8 import java.util.HashMap;
    9 import java.util.Map;
     8import java.util.logging.Logger;
    109
    1110import javax.swing.JLabel;
     
    1514import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.OsmPrimitive;
     16import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1717import org.openstreetmap.josm.tools.ImageProvider;
    1818
    1919/**
    20  * Represents a command for undeleting a node which was deleted on the server.
     20 * Represents a command for undeleting an {@see OsmPrimitive} which was deleted on the server.
    2121 * The command remembers the former node id and sets the node id to 0. This turns
    2222 * the node into a new node which can be uploaded to the server.
    2323 *
    2424 */
    25 public class UndeletePrimitivesCommand extends Command {
     25public class UndeletePrimitivesCommand extends ConflictResolveCommand {
     26    static private final Logger logger = Logger.getLogger(UndeletePrimitivesCommand.class.getName());
    2627
    2728    /** the node to undelete */
    2829    private ArrayList<OsmPrimitive> toUndelete;
    29     private Map<OsmPrimitive,OsmPrimitive> resolvedConflicts;
    3030
    3131    protected UndeletePrimitivesCommand() {
    3232        toUndelete = new ArrayList<OsmPrimitive>();
    33         resolvedConflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
    3433    }
    3534    /**
     
    7776    public boolean executeCommand() {
    7877        super.executeCommand();
     78
    7979        for(OsmPrimitive primitive: toUndelete) {
    80             if (Main.map.conflictDialog.conflicts.containsKey(primitive)) {
    81                 resolvedConflicts.put(primitive, Main.map.conflictDialog.conflicts.get(primitive));
    82                 Main.map.conflictDialog.removeConflictForPrimitive(primitive);
     80            if(getLayer().getConflicts().hasConflictForMy(primitive)) {
     81                rememberConflict(getLayer().getConflicts().getConflictForMy(primitive));
     82                getLayer().getConflicts().remove(primitive);
    8383            }
    8484            primitive.id = 0;
     
    9292        modified.addAll(toUndelete);
    9393    }
    94     @Override
    95     public void undoCommand() {
    96         super.undoCommand();
    97 
    98         for (OsmPrimitive my: resolvedConflicts.keySet()) {
    99             if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    100                 Main.map.conflictDialog.addConflict(my, resolvedConflicts.get(my));
    101             }
    102         }
    103     }
    10494}
  • trunk/src/org/openstreetmap/josm/command/VersionConflictResolveCommand.java

    r1690 r1750  
    1010import javax.swing.tree.MutableTreeNode;
    1111
    12 import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.data.conflict.Conflict;
    1313import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     
    2020 *
    2121 */
    22 public class VersionConflictResolveCommand extends Command {
     22public class VersionConflictResolveCommand extends ConflictResolveCommand {
    2323
    24     private final OsmPrimitive my;
    25     private final OsmPrimitive their;
     24    /** the conflict to resolve */
     25    private Conflict<OsmPrimitive> conflict;
    2626
    2727    /**
     
    3131     */
    3232    public VersionConflictResolveCommand(OsmPrimitive my, OsmPrimitive their) {
    33         this.my = my;
    34         this.their = their;
     33        conflict = new Conflict<OsmPrimitive>(my, their);
    3534    }
    3635
     
    3938        return new DefaultMutableTreeNode(
    4039                new JLabel(
    41                         tr("Resolve version conflicts for {0} {1}",OsmPrimitiveType.from(my).getLocalizedDisplayNameSingular(), my.id),
     40                        tr("Resolve version conflicts for {0} {1}",OsmPrimitiveType.from(conflict.getMy()).getLocalizedDisplayNameSingular(),conflict.getMy().id),
    4241                        ImageProvider.get("data", "object"),
    4342                        JLabel.HORIZONTAL
     
    4948    public boolean executeCommand() {
    5049        super.executeCommand();
    51         my.version = Math.max(my.version, their.version);
    52         Main.map.conflictDialog.removeConflictForPrimitive(my);
     50        conflict.getMy().version = Math.max(conflict.getMy().version, conflict.getTheir().version);
     51        getLayer().getConflicts().remove(conflict);
     52        rememberConflict(conflict);
    5353        return true;
    5454    }
     
    5757    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    5858            Collection<OsmPrimitive> added) {
    59         modified.add(my);
    60     }
    61 
    62     @Override
    63     public void undoCommand() {
    64         super.undoCommand();
    65 
    66         // restore a conflict if necessary
    67         //
    68         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    69             Main.map.conflictDialog.addConflict(my, their);
    70         }
     59        modified.add(conflict.getMy());
    7160    }
    7261}
  • trunk/src/org/openstreetmap/josm/command/WayNodesConflictResolverCommand.java

    r1654 r1750  
    66import java.util.Collection;
    77import java.util.List;
     8import java.util.logging.Logger;
    89
    910import javax.swing.JLabel;
     
    1112import javax.swing.tree.MutableTreeNode;
    1213
    13 import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.data.conflict.Conflict;
    1415import org.openstreetmap.josm.data.osm.Node;
    1516import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2223 *
    2324 */
    24 public class WayNodesConflictResolverCommand extends Command {
     25public class WayNodesConflictResolverCommand extends ConflictResolveCommand {
    2526
    26     /** my way */
    27     private final Way my;
    28     /** their way */
    29     private final Way their;
     27    static private final Logger logger = Logger.getLogger(WayNodesConflictResolverCommand.class.getName());
     28
     29    /** the conflict to resolve */
     30    private Conflict<Way> conflict;
     31
    3032    /** the list of merged nodes. This becomes the list of news of my way after the
    3133     *  command is executed
    3234     */
    3335    private final List<Node> mergedNodeList;
     36
    3437
    3538    /**
     
    4043     */
    4144    public WayNodesConflictResolverCommand(Way my, Way their, List<Node> mergedNodeList) {
    42         this.my = my;
    43         this.their = their;
     45        conflict = new Conflict<Way>(my,their);
    4446        this.mergedNodeList = mergedNodeList;
    4547    }
     
    5052        return new DefaultMutableTreeNode(
    5153                new JLabel(
    52                         tr("Resolve conflicts in node list of of way {0}", my.id),
     54                        tr("Resolve conflicts in node list of of way {0}", conflict.getMy().id),
    5355                        ImageProvider.get("data", "object"),
    5456                        JLabel.HORIZONTAL
     
    6668        // nodes
    6769        //
    68         my.nodes.clear();
     70        conflict.getMy().nodes.clear();
    6971        for (int i=0; i<mergedNodeList.size();i++) {
    7072            Node n = mergedNodeList.get(i);
    71             my.nodes.add(n);
    72             if (! Main.ds.nodes.contains(n)) {
    73                 System.out.println("Main.ds doesn't include node " + n.toString());
     73            conflict.getMy().nodes.add(n);
     74            if (! getLayer().data.nodes.contains(n)) {
     75                logger.warning(tr("Main.ds doesn't include node {0}", n.toString()));
    7476            }
    7577        }
     78        rememberConflict(conflict);
    7679        return true;
    7780    }
     
    8083    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted,
    8184            Collection<OsmPrimitive> added) {
    82         modified.add(my);
    83     }
    84 
    85     @Override
    86     public void undoCommand() {
    87         // restore the former state
    88         //
    89         super.undoCommand();
    90 
    91         // restore a conflict if necessary
    92         //
    93         if (!Main.map.conflictDialog.conflicts.containsKey(my)) {
    94             Main.map.conflictDialog.addConflict(my, their);
    95         }
     85        modified.add(conflict.getMy());
    9686    }
    9787}
  • trunk/src/org/openstreetmap/josm/data/osm/Node.java

    r1747 r1750  
    55
    66import org.openstreetmap.josm.Main;
     7import org.openstreetmap.josm.data.coor.CachedLatLon;
    78import org.openstreetmap.josm.data.coor.EastNorth;
    8 import org.openstreetmap.josm.data.coor.CachedLatLon;
    99import org.openstreetmap.josm.data.coor.LatLon;
    1010import org.openstreetmap.josm.data.coor.LatLon.CoordinateFormat;
    11 import org.openstreetmap.josm.data.projection.Projection;
    1211import org.openstreetmap.josm.data.osm.visitor.Visitor;
    13 import org.openstreetmap.josm.data.osm.Node;
    1412
    1513/**
     
    2523        if(coor != null)
    2624        {
    27             if(this.coor == null)
     25            if(this.coor == null) {
    2826                this.coor = new CachedLatLon(coor);
    29             else
     27            } else {
    3028                this.coor.setCoor(coor);
     29            }
    3130        }
    3231    }
     
    3938        if(eastNorth != null)
    4039        {
    41             if(coor != null)
     40            if(coor != null) {
    4241                coor.setEastNorth(eastNorth);
    43             else
     42            } else {
    4443                coor = new CachedLatLon(eastNorth);
     44            }
    4545        }
    4646    }
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

    r1701 r1750  
    1010import java.util.logging.Logger;
    1111
     12import org.openstreetmap.josm.data.conflict.ConflictCollection;
    1213import org.openstreetmap.josm.data.osm.DataSet;
    1314import org.openstreetmap.josm.data.osm.Node;
     
    3132     * round than merged)
    3233     */
    33     private Map<OsmPrimitive, OsmPrimitive> conflicts;
     34    private ConflictCollection conflicts;
     35
    3436
    3537    private final DataSet myDataSet;
     
    6870            relshash.put(r.id, r);
    6971        }
    70         conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
     72        conflicts = new ConflictCollection();
    7173        merged = new HashMap<OsmPrimitive, OsmPrimitive>();
    7274    }
     
    113115                        // differences in deleted state have to be merged manually
    114116                        //
    115                         conflicts.put(my, other);
     117                        conflicts.add(my, other);
    116118                    } else {
    117119                        // copy the technical attributes from other
     
    158160            fixRelation(r);
    159161        }
    160         for (OsmPrimitive osm : conflicts.values())
     162        for (OsmPrimitive osm : conflicts.getMyConflictParties())
    161163            if (osm instanceof Way) {
    162164                fixWay((Way)osm);
     
    235237                    // because it was deleted on the server.
    236238                    //
    237                     conflicts.put(my,other);
     239                    conflicts.add(my,other);
    238240                } else if (my.incomplete) {
    239241                    // my is incomplete, other completes it
     
    250252                    // differences in deleted state have to be resolved manually
    251253                    //
    252                     conflicts.put(my,other);
     254                    conflicts.add(my,other);
    253255                } else if (! my.modified && other.modified) {
    254256                    // my not modified. We can assume that other is the most recent version.
     
    278280                    // resolve the differences
    279281                    // =>  create a conflict
    280                     conflicts.put(my,other);
     282                    conflicts.add(my,other);
    281283                } else {
    282284                    // clone from other, but keep the modified flag. Clone will mainly copy
     
    326328     * @return the map of conflicts
    327329     */
    328     public Map<OsmPrimitive, OsmPrimitive> getConflicts() {
     330    public ConflictCollection getConflicts() {
    329331        return conflicts;
    330332    }
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r1722 r1750  
    99import java.awt.Graphics2D;
    1010import java.awt.Point;
     11import java.awt.event.ComponentAdapter;
     12import java.awt.event.ComponentEvent;
    1113import java.awt.event.MouseEvent;
    1214import java.awt.event.MouseMotionListener;
    13 import java.awt.event.ComponentAdapter;
    14 import java.awt.event.ComponentEvent;
    1515import java.awt.image.BufferedImage;
    1616import java.util.ArrayList;
    17 import java.util.Enumeration;
    1817import java.util.Collection;
    1918import java.util.Collections;
     19import java.util.Enumeration;
    2020import java.util.LinkedList;
    2121
     
    2727import org.openstreetmap.josm.actions.AutoScaleAction;
    2828import org.openstreetmap.josm.actions.JosmAction;
     29import org.openstreetmap.josm.actions.MoveAction;
    2930import org.openstreetmap.josm.actions.mapmode.MapMode;
    30 import org.openstreetmap.josm.actions.MoveAction;
    31 import org.openstreetmap.josm.data.Bounds;
    3231import org.openstreetmap.josm.data.ProjectionBounds;
    3332import org.openstreetmap.josm.data.SelectionChangedListener;
    34 import org.openstreetmap.josm.data.coor.EastNorth;
    35 import org.openstreetmap.josm.data.coor.LatLon;
    3633import org.openstreetmap.josm.data.osm.DataSet;
    3734import org.openstreetmap.josm.data.osm.DataSource;
    3835import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3936import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    40 import org.openstreetmap.josm.data.projection.Projection;
    4137import org.openstreetmap.josm.gui.layer.Layer;
    4238import org.openstreetmap.josm.gui.layer.MapViewPaintable;
     
    6157public class MapView extends NavigatableComponent {
    6258
     59
    6360    /**
    6461     * A list of all layers currently loaded.
     
    6966     */
    7067    public PlayHeadMarker playHeadMarker = null;
    71     /**
    72      * Direct link to the edit layer (if any) in the layers list.
    73      */
    74     public OsmDataLayer editLayer;
     68
    7569    /**
    7670     * The layer from the layers list that is currently active.
     
    10094                scaler.setLocation(10,30);
    10195
    102                 if (!zoomToEditLayerBoundingBox())
     96                if (!zoomToEditLayerBoundingBox()) {
    10397                    new AutoScaleAction("data").actionPerformed(null);
     98                }
    10499
    105100                new MapMover(MapView.this, Main.contentPane);
     
    152147    public void addLayer(Layer layer) {
    153148        if (layer instanceof OsmDataLayer) {
    154             editLayer = (OsmDataLayer)layer;
     149            OsmDataLayer editLayer = (OsmDataLayer)layer;
    155150            Main.ds = editLayer.data;
    156151            editLayer.listenerModified.add(new ModifiedChangedListener(){
    157152                public void modifiedChanged(boolean value, OsmDataLayer source) {
    158153                    JOptionPane.getFrameForComponent(Main.parent).setTitle((value?"*":"")
    159                     +tr("Java OpenStreetMap Editor"));
     154                            +tr("Java OpenStreetMap Editor"));
    160155                }
    161156            });
    162157        }
    163         if (layer instanceof MarkerLayer && playHeadMarker == null)
     158        if (layer instanceof MarkerLayer && playHeadMarker == null) {
    164159            playHeadMarker = PlayHeadMarker.create();
     160        }
    165161        int pos = layers.size();
    166         while(pos > 0 && layers.get(pos-1).background)
     162        while(pos > 0 && layers.get(pos-1).background) {
    167163            --pos;
     164        }
    168165        layers.add(pos, layer);
    169166
    170         for (Layer.LayerChangeListener l : Layer.listeners)
     167        for (Layer.LayerChangeListener l : Layer.listeners) {
    171168            l.layerAdded(layer);
     169        }
    172170        if (layer instanceof OsmDataLayer || activeLayer == null) {
    173171            // autoselect the new layer
    174172            Layer old = activeLayer;
    175173            setActiveLayer(layer);
    176             for (Layer.LayerChangeListener l : Layer.listeners)
     174            for (Layer.LayerChangeListener l : Layer.listeners) {
    177175                l.activeLayerChange(old, layer);
     176            }
    178177        }
    179178        AudioPlayer.reset();
     
    182181
    183182    @Override
    184     protected DataSet getData()
    185     {
     183    protected DataSet getData() {
    186184        if(activeLayer != null && activeLayer instanceof OsmDataLayer)
    187185            return ((OsmDataLayer)activeLayer).data;
     
    189187    }
    190188
    191     public Boolean isDrawableLayer()
    192     {
     189    /**
     190     * Replies true if the active layer is drawable.
     191     *
     192     * @return true if the active layer is drawable, false otherwise
     193     */
     194    public boolean isActiveLayerDrawable() {
    193195        return activeLayer != null && activeLayer instanceof OsmDataLayer;
    194196    }
    195197
    196     public Boolean isVisibleDrawableLayer() {
    197         return isDrawableLayer() && activeLayer.visible;
     198    /**
     199     * Replies true if the active layer is visible.
     200     *
     201     * @return true if the active layer is visible, false otherwise
     202     */
     203    public boolean isActiveLayerVisible() {
     204        return isActiveLayerDrawable() && activeLayer.visible;
    198205    }
    199206
     
    204211    public void removeLayer(Layer layer) {
    205212        if (layers.remove(layer)) {
    206             for (Layer.LayerChangeListener l : Layer.listeners)
     213            for (Layer.LayerChangeListener l : Layer.listeners) {
    207214                l.layerRemoved(layer);
    208         }
    209         if (layer == editLayer) {
    210             editLayer = null;
    211             Main.ds.setSelected();
     215            }
     216        }
     217        if (layer == activeLayer) {
     218            if (layer instanceof OsmDataLayer) {
     219                Main.ds.setSelected();
     220            }
    212221        }
    213222        layer.destroy();
     
    215224    }
    216225
    217     private Boolean virtualnodes = false;
    218     public void enableVirtualNodes(Boolean state)
    219     {
    220         if(virtualnodes != state)
    221         {
    222             virtualnodes = state;
     226    private boolean virtualNodesEnabled = false;
     227    public void setVirtualNodesEnabled(boolean enabled) {
     228        if(virtualNodesEnabled != enabled) {
     229            virtualNodesEnabled = enabled;
    223230            repaint();
    224231        }
    225232    }
    226     public Boolean useVirtualNodes()
    227     {
    228         return virtualnodes;
     233    public boolean isVirtualNodesEnabled() {
     234        return virtualNodesEnabled;
    229235    }
    230236
     
    241247            return; // already in place.
    242248        layers.remove(curLayerPos);
    243         if (pos >= layers.size())
     249        if (pos >= layers.size()) {
    244250            layers.add(layer);
    245         else
     251        } else {
    246252            layers.add(pos, layer);
     253        }
    247254        AudioPlayer.reset();
    248255    }
     
    266273        // just re-use it.
    267274        if (null == offscreenBuffer || offscreenBuffer.getWidth() != getWidth()
    268                 || offscreenBuffer.getHeight() != getHeight())
     275                || offscreenBuffer.getHeight() != getHeight()) {
    269276            offscreenBuffer = new BufferedImage(getWidth(), getHeight(),
    270277                    BufferedImage.TYPE_INT_ARGB);
     278        }
    271279
    272280        Graphics2D tempG = offscreenBuffer.createGraphics();
     
    276284        for (int i = layers.size()-1; i >= 0; --i) {
    277285            Layer l = layers.get(i);
    278             if (l.visible/* && l != getActiveLayer()*/)
     286            if (l.visible/* && l != getActiveLayer()*/) {
    279287                l.paint(tempG, this);
     288            }
    280289        }
    281290
     
    296305        int x2 = Math.max(min.x, max.x);
    297306        int y2 = Math.max(min.y, max.y);
    298         if (x1 > 0 || y1 > 0 || x2 < getWidth() || y2 < getHeight())
     307        if (x1 > 0 || y1 > 0 || x2 < getWidth() || y2 < getHeight()) {
    299308            tempG.drawRect(x1, y1, x2-x1+1, y2-y1+1);
    300 
    301         if (playHeadMarker != null)
     309        }
     310
     311        if (playHeadMarker != null) {
    302312            playHeadMarker.paint(tempG, this);
     313        }
    303314
    304315        g.drawImage(offscreenBuffer, 0, 0, null);
     
    310321     */
    311322    public void recalculateCenterScale(BoundingXYVisitor box) {
    312         if(box == null)
     323        if(box == null) {
    313324            box = new BoundingXYVisitor();
    314         if(box.getBounds() == null)
     325        }
     326        if(box.getBounds() == null) {
    315327            box.visit(getProjection().getWorldBounds());
    316         if(!box.hasExtend())
    317              box.enlargeBoundingBox();
     328        }
     329        if(!box.hasExtend()) {
     330            box.enlargeBoundingBox();
     331        }
    318332
    319333        zoomTo(box.getBounds());
     
    321335
    322336    /**
    323      * @return An unmodificable list of all layers
     337     * @return An unmodifiable collection of all layers
    324338     */
    325339    public Collection<Layer> getAllLayers() {
     
    328342
    329343    /**
    330      * Set the active selection to the given value and raise an layerchange event.
     344     * Sets the active layer to <code>layer</code>. If <code>layer</code> is an instance
     345     * of {@see OsmDataLayer} also sets {@see #editLayer} to <code>layer</code>.
     346     *
     347     * @param layer the layer to be activate; must be one of the layers in the list of layers
     348     * @exception IllegalArgumentException thrown if layer is not in the lis of layers
    331349     */
    332350    public void setActiveLayer(Layer layer) {
    333351        if (!layers.contains(layer))
    334             throw new IllegalArgumentException("Layer must be in layerlist");
     352            throw new IllegalArgumentException(tr("Layer {0} must be in list of layers", layer.toString()));
    335353        if (layer instanceof OsmDataLayer) {
    336             editLayer = (OsmDataLayer)layer;
     354            OsmDataLayer editLayer = (OsmDataLayer)layer;
    337355            Main.ds = editLayer.data;
    338         }
    339         else
     356        } else {
    340357            Main.ds.setSelected();
     358        }
    341359        DataSet.fireSelectionChanged(Main.ds.getSelected());
    342360        Layer old = activeLayer;
    343361        activeLayer = layer;
    344362        if (old != layer) {
    345             for (Layer.LayerChangeListener l : Layer.listeners)
     363            for (Layer.LayerChangeListener l : Layer.listeners) {
    346364                l.activeLayerChange(old, layer);
     365            }
    347366        }
    348367
     
    360379
    361380    /**
    362      * @return The current active layer
     381     * Replies the currently active layer
     382     *
     383     * @return the currently active layer (may be null)
    363384     */
    364385    public Layer getActiveLayer() {
    365386        return activeLayer;
     387    }
     388
     389    /**
     390     * Replies the current edit layer, if any
     391     *
     392     * @return the current edit layer. May be null.
     393     */
     394    public OsmDataLayer getEditLayer() {
     395        if (activeLayer instanceof OsmDataLayer)
     396            return (OsmDataLayer)activeLayer;
     397        return null;
     398    }
     399
     400    /**
     401     * replies true if the list of layers managed by this map view contain layer
     402     *
     403     * @param layer the layer
     404     * @return true if the list of layers managed by this map view contain layer
     405     */
     406    public boolean hasLayer(Layer layer) {
     407        return layers.contains(layer);
    366408    }
    367409
     
    377419        // workaround for #1461 (zoom to download bounding box instead of all data)
    378420        // In case we already have an existing data layer ...
    379         Collection<DataSource> dataSources = Main.main.editLayer().data.dataSources;
     421        Collection<DataSource> dataSources = Main.main.createOrGetEditLayer().data.dataSources;
    380422        // ... with bounding box[es] of data loaded from OSM or a file...
    381423        BoundingXYVisitor bbox = new BoundingXYVisitor();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/CommandStackDialog.java

    r1706 r1750  
    2929    public CommandStackDialog(final MapFrame mapFrame) {
    3030        super(tr("Command Stack"), "commandstack", tr("Open a list of all commands (undo buffer)."),
    31         Shortcut.registerShortcut("subwindow:commandstack", tr("Toggle: {0}", tr("Command Stack")), KeyEvent.VK_O, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 100);
     31                Shortcut.registerShortcut("subwindow:commandstack", tr("Toggle: {0}", tr("Command Stack")), KeyEvent.VK_O, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 100);
    3232        Main.main.undoRedo.listenerCommands.add(this);
    3333
     
    5252
    5353    @Override public void setVisible(boolean v) {
    54         if (v)
     54        if (v) {
    5555            buildList();
    56         else if (tree != null)
     56        } else if (tree != null) {
    5757            treeModel.setRoot(new DefaultMutableTreeNode());
     58        }
    5859        super.setVisible(v);
    5960    }
     
    6566            setTitle(tr("Command Stack"), false);
    6667        }
    67         if (Main.map == null || Main.map.mapView == null || Main.map.mapView.editLayer == null)
     68        if (Main.map == null || Main.map.mapView == null || Main.map.mapView.getEditLayer() == null)
    6869            return;
    6970        Collection<Command> commands = Main.main.undoRedo.commands;
    7071        DefaultMutableTreeNode root = new DefaultMutableTreeNode();
    71         for (Command c : commands)
     72        for (Command c : commands) {
    7273            root.add(c.description());
     74        }
    7375        treeModel.setRoot(root);
    7476        tree.scrollRowToVisible(treeModel.getChildCount(root)-1);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r1725 r1750  
    1111import java.awt.Point;
    1212import java.awt.event.ActionEvent;
    13 import java.awt.event.ActionListener;
    1413import java.awt.event.KeyEvent;
    1514import java.awt.event.MouseAdapter;
    1615import java.awt.event.MouseEvent;
    1716import java.util.Collection;
    18 import java.util.HashMap;
     17import java.util.Iterator;
    1918import java.util.LinkedList;
    20 import java.util.Map;
    21 
    22 import javax.swing.DefaultListModel;
     19import java.util.concurrent.CopyOnWriteArrayList;
     20
     21import javax.swing.AbstractAction;
     22import javax.swing.JButton;
    2323import javax.swing.JList;
    2424import javax.swing.JPanel;
    2525import javax.swing.JScrollPane;
     26import javax.swing.ListModel;
    2627import javax.swing.ListSelectionModel;
     28import javax.swing.event.ListDataEvent;
     29import javax.swing.event.ListDataListener;
    2730import javax.swing.event.ListSelectionEvent;
    2831import javax.swing.event.ListSelectionListener;
     
    3033import org.openstreetmap.josm.Main;
    3134import org.openstreetmap.josm.data.SelectionChangedListener;
     35import org.openstreetmap.josm.data.conflict.Conflict;
     36import org.openstreetmap.josm.data.conflict.ConflictCollection;
     37import org.openstreetmap.josm.data.conflict.IConflictListener;
    3238import org.openstreetmap.josm.data.osm.DataSet;
    3339import org.openstreetmap.josm.data.osm.Node;
     
    4046import org.openstreetmap.josm.gui.NavigatableComponent;
    4147import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    42 import org.openstreetmap.josm.gui.SideButton;
     48import org.openstreetmap.josm.gui.layer.Layer;
     49import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     50import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
     51import org.openstreetmap.josm.tools.ImageProvider;
    4352import org.openstreetmap.josm.tools.Shortcut;
    4453
    45 public final class ConflictDialog extends ToggleDialog {
    46 
    47     public final Map<OsmPrimitive, OsmPrimitive> conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
    48     private final DefaultListModel model = new DefaultListModel();
    49     private final JList displaylist = new JList(model);
    50 
    51     private final SideButton sbSelect = new SideButton(marktr("Select"), "select", "Conflict",
    52             tr("Set the selected elements on the map to the selected items in the list above."), new ActionListener(){
    53         public void actionPerformed(ActionEvent e) {
    54             Collection<OsmPrimitive> sel = new LinkedList<OsmPrimitive>();
    55             for (Object o : displaylist.getSelectedValues()) {
    56                 sel.add((OsmPrimitive)o);
    57             }
    58             Main.ds.setSelected(sel);
    59         }
    60     });
    61     private final SideButton sbResolve = new SideButton(marktr("Resolve"), "conflict", "Conflict",
    62             tr("Open a merge dialog of all selected items in the list above."), new ActionListener(){
    63         public void actionPerformed(ActionEvent e) {
    64             resolve();
    65         }
    66     });
    67 
    68     public ConflictDialog() {
    69         super(tr("Conflict"), "conflict", tr("Merging conflicts."),
    70                 Shortcut.registerShortcut("subwindow:conflict", tr("Toggle: {0}", tr("Conflict")), KeyEvent.VK_C, Shortcut.GROUP_LAYER), 100);
    71         displaylist.setCellRenderer(new OsmPrimitivRenderer());
    72         displaylist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
    73         displaylist.addMouseListener(new MouseAdapter(){
     54/**
     55 * This dialog displays the {@see ConflictCollection} of the active {@see OsmDataLayer} in a toggle
     56 * dialog on the right of the main frame.
     57 *
     58 */
     59public final class ConflictDialog extends ToggleDialog implements LayerChangeListener, IConflictListener, SelectionChangedListener{
     60
     61    static public Color getColor() {
     62        return Main.pref.getColor(marktr("conflict"), Color.gray);
     63    }
     64
     65    /** the  collection of conflicts displayed by this conflict dialog*/
     66    private ConflictCollection conflicts;
     67
     68    /** the model for the list of conflicts */
     69    private ConflictListModel model;
     70    /** the list widget for the list of conflicts */
     71    private JList lstConflicts;
     72
     73    private ResolveAction actResolve;
     74    private SelectAction actSelect;
     75
     76    private OsmDataLayer layer = null;
     77
     78
     79    /**
     80     * builds the GUI
     81     */
     82    protected void build() {
     83        model = new ConflictListModel();
     84
     85        lstConflicts = new JList(model);
     86        lstConflicts.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
     87        lstConflicts.setCellRenderer(new OsmPrimitivRenderer());
     88        lstConflicts.addMouseListener(new MouseAdapter(){
    7489            @Override public void mouseClicked(MouseEvent e) {
    7590                if (e.getClickCount() >= 2) {
     
    7893            }
    7994        });
    80         add(new JScrollPane(displaylist), BorderLayout.CENTER);
    81 
    82         JPanel buttonPanel = new JPanel(new GridLayout(1,2));
    83         buttonPanel.add(sbResolve);
    84         buttonPanel.add(sbSelect);
    85         add(buttonPanel, BorderLayout.SOUTH);
    86 
    87         DataSet.selListeners.add(new SelectionChangedListener(){
    88             public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    89                 displaylist.clearSelection();
    90                 for (OsmPrimitive osm : newSelection) {
    91                     if (conflicts.containsKey(osm)) {
    92                         int pos = model.indexOf(osm);
    93                         displaylist.addSelectionInterval(pos, pos);
    94                     }
    95                 }
    96             }
    97         });
    98         displaylist.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
     95        lstConflicts.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
    9996            public void valueChanged(ListSelectionEvent e) {
    10097                Main.map.mapView.repaint();
     
    10299        });
    103100
    104         rebuildList();
    105     }
    106 
     101        add(new JScrollPane(lstConflicts), BorderLayout.CENTER);
     102
     103        JButton btnResolve = new JButton(actResolve = new ResolveAction());
     104        lstConflicts.getSelectionModel().addListSelectionListener(actResolve);
     105
     106        JButton btnSelect = new JButton(actSelect = new SelectAction());
     107        lstConflicts.getSelectionModel().addListSelectionListener(actSelect);
     108
     109        JPanel buttonPanel = new JPanel(new GridLayout(1,2));
     110        buttonPanel.add(btnResolve);
     111        buttonPanel.add(btnSelect);
     112        add(buttonPanel, BorderLayout.SOUTH);
     113    }
     114
     115    /**
     116     * constructor
     117     */
     118    public ConflictDialog() {
     119        super(tr("Conflict"), "conflict", tr("Merging conflicts."),
     120                Shortcut.registerShortcut("subwindow:conflict", tr("Toggle: {0}", tr("Conflict")), KeyEvent.VK_C, Shortcut.GROUP_LAYER), 100);
     121
     122        build();
     123        DataSet.selListeners.add(this);
     124        Layer.listeners.add(this);
     125        refreshView();
     126    }
     127
     128    /**
     129     * Launches a conflict resolution dialog for the first selected conflict
     130     *
     131     */
    107132    private final void resolve() {
    108         if(model.size() == 1) {
    109             displaylist.setSelectedIndex(0);
    110         }
    111 
    112         if (displaylist.getSelectedIndex() == -1)
     133        if (conflicts == null) return;
     134        if (conflicts.size() == 1) {
     135            lstConflicts.setSelectedIndex(0);
     136        }
     137
     138        if (lstConflicts.getSelectedIndex() == -1)
    113139            return;
    114140
    115         int [] selectedRows = displaylist.getSelectedIndices();
     141        int [] selectedRows = lstConflicts.getSelectedIndices();
    116142        if (selectedRows == null || selectedRows.length == 0)
    117143            return;
    118144        int row = selectedRows[0];
    119         OsmPrimitive my = (OsmPrimitive)model.get(row);
    120         OsmPrimitive their = conflicts.get(my);
     145        Conflict c = conflicts.get(row);
     146        OsmPrimitive my = c.getMy();
     147        OsmPrimitive their = c.getTheir();
    121148        ConflictResolutionDialog dialog = new ConflictResolutionDialog(Main.parent);
    122149        dialog.getConflictResolver().populate(my, their);
     
    125152    }
    126153
    127     public final void rebuildList() {
    128         model.removeAllElements();
    129         for (OsmPrimitive osm : this.conflicts.keySet()) {
    130             model.addElement(osm);
    131         }
    132 
    133         if(model.size() != 0) {
    134             setTitle(tr("Conflicts: {0}", model.size()), true);
    135         } else {
    136             setTitle(tr("Conflicts"), false);
    137         }
    138 
    139         sbSelect.setEnabled(model.size() > 0);
    140         sbResolve.setEnabled(model.size() > 0);
    141     }
    142 
    143     public final void add(Map<OsmPrimitive, OsmPrimitive> conflicts) {
    144         this.conflicts.putAll(conflicts);
    145         rebuildList();
    146     }
    147 
    148 
    149     /**
    150      * removes a conflict registered for {@see OsmPrimitive} <code>my</code>
    151      *
    152      * @param my the {@see OsmPrimitive} for which a conflict is registered
    153      *   with this dialog
    154      */
    155     public void removeConflictForPrimitive(OsmPrimitive my) {
    156         if (! conflicts.keySet().contains(my))
    157             return;
    158         conflicts.remove(my);
    159         rebuildList();
    160         repaint();
    161     }
    162 
    163     /**
    164      * registers a conflict with this dialog. The conflict is represented
    165      * by a pair of {@see OsmPrimitive} with differences in their tag sets,
    166      * their node lists (for {@see Way}s) or their member lists (for {@see Relation}s)
    167      *
    168      * @param my  my version of the {@see OsmPrimitive}
    169      * @param their their version of the {@see OsmPrimitive}
    170      */
    171     public void addConflict(OsmPrimitive my, OsmPrimitive their) {
    172         conflicts.put(my, their);
    173         rebuildList();
    174         repaint();
    175     }
    176 
    177     static public Color getColor()
    178     {
    179         return Main.pref.getColor(marktr("conflict"), Color.gray);
     154
     155    /**
     156     * refreshes the view of this dialog
     157     */
     158    public final void refreshView() {
     159        model.fireContentChanged();
    180160    }
    181161
     
    215195            }
    216196        };
    217         for (Object o : displaylist.getSelectedValues()) {
    218             if (conflicts.get(o) == null) {
     197        for (Object o : lstConflicts.getSelectedValues()) {
     198            if (!conflicts.hasConflictForMy((OsmPrimitive)o)) {
    219199                continue;
    220200            }
    221             conflicts.get(o).visit(conflictPainter);
     201            conflicts.getConflictForMy((OsmPrimitive)o).getTheir().visit(conflictPainter);
     202        }
     203    }
     204
     205
     206    /**
     207     * replies the conflict collection currently held by this dialog; may be null
     208     *
     209     * @return the conflict collection currently held by this dialog; may be null
     210     */
     211    public ConflictCollection getConflicts() {
     212        return conflicts;
     213    }
     214
     215    /**
     216     * invoked if the active {@see Layer} changes
     217     */
     218    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     219        if (oldLayer instanceof OsmDataLayer) {
     220            this.layer = (OsmDataLayer)oldLayer;
     221            this.layer.getConflicts().removeConflictListener(this);
     222        }
     223        this.layer = null;
     224        if (newLayer instanceof OsmDataLayer) {
     225            this.layer = (OsmDataLayer)newLayer;
     226            layer.getConflicts().addConflictListener(this);
     227            this.conflicts = layer.getConflicts();
     228        }
     229        refreshView();
     230    }
     231
     232    public void layerAdded(Layer newLayer) {
     233        // ignore
     234    }
     235
     236    public void layerRemoved(Layer oldLayer) {
     237        if (this.layer == oldLayer) {
     238            this.layer = null;
     239            refreshView();
     240        }
     241    }
     242
     243    public void onConflictsAdded(ConflictCollection conflicts) {
     244        refreshView();
     245    }
     246
     247    public void onConflictsRemoved(ConflictCollection conflicts) {
     248        refreshView();
     249    }
     250
     251    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     252        lstConflicts.clearSelection();
     253        for (OsmPrimitive osm : newSelection) {
     254            if (conflicts.hasConflictForMy(osm)) {
     255                int pos = model.indexOf(osm);
     256                if (pos >= 0) {
     257                    lstConflicts.addSelectionInterval(pos, pos);
     258                }
     259            }
     260        }
     261    }
     262
     263    /**
     264     * The {@see ListModel} for conflicts
     265     *
     266     */
     267    class ConflictListModel implements ListModel {
     268
     269        private CopyOnWriteArrayList<ListDataListener> listeners;
     270
     271        public ConflictListModel() {
     272            listeners = new CopyOnWriteArrayList<ListDataListener>();
     273        }
     274
     275        public void addListDataListener(ListDataListener l) {
     276            if (l != null && ! listeners.contains(l)) {
     277                listeners.add(l);
     278            }
     279        }
     280
     281        public void removeListDataListener(ListDataListener l) {
     282            listeners.remove(l);
     283        }
     284
     285        protected void fireContentChanged() {
     286            ListDataEvent evt = new ListDataEvent(
     287                    this,
     288                    ListDataEvent.CONTENTS_CHANGED,
     289                    0,
     290                    getSize()
     291            );
     292            Iterator<ListDataListener> it = listeners.iterator();
     293            while(it.hasNext()) {
     294                it.next().contentsChanged(evt);
     295            }
     296        }
     297
     298        public Object getElementAt(int index) {
     299            if (index < 0) return null;
     300            if (index >= getSize()) return null;
     301            return conflicts.get(index).getMy();
     302        }
     303
     304        public int getSize() {
     305            if (conflicts == null) return 0;
     306            return conflicts.size();
     307        }
     308
     309        public int indexOf(OsmPrimitive my) {
     310            if (conflicts == null) return -1;
     311            for (int i=0; i < conflicts.size();i++) {
     312                if (conflicts.get(i).isMatchingMy(my))
     313                    return i;
     314            }
     315            return -1;
     316        }
     317
     318        public OsmPrimitive get(int idx) {
     319            if (conflicts == null) return null;
     320            return conflicts.get(idx).getMy();
     321        }
     322    }
     323
     324    class ResolveAction extends AbstractAction implements ListSelectionListener {
     325        public ResolveAction() {
     326            putValue(NAME, tr("Resolve"));
     327            putValue(SHORT_DESCRIPTION,  tr("Open a merge dialog of all selected items in the list above."));
     328            putValue(SMALL_ICON, ImageProvider.get("dialogs", "conflict"));
     329        }
     330
     331        public void actionPerformed(ActionEvent e) {
     332            resolve();
     333        }
     334
     335        public void valueChanged(ListSelectionEvent e) {
     336            ListSelectionModel model = (ListSelectionModel)e.getSource();
     337            boolean enabled = model.getMinSelectionIndex() >= 0
     338            && model.getMaxSelectionIndex() >= model.getMinSelectionIndex();
     339            setEnabled(enabled);
     340        }
     341    }
     342
     343    class SelectAction extends AbstractAction implements ListSelectionListener {
     344        public SelectAction() {
     345            putValue(NAME, tr("Select"));
     346            putValue(SHORT_DESCRIPTION,  tr("Set the selected elements on the map to the selected items in the list above."));
     347            putValue(SMALL_ICON, ImageProvider.get("dialogs", "select"));
     348        }
     349
     350        public void actionPerformed(ActionEvent e) {
     351            Collection<OsmPrimitive> sel = new LinkedList<OsmPrimitive>();
     352            for (Object o : lstConflicts.getSelectedValues()) {
     353                sel.add((OsmPrimitive)o);
     354            }
     355            Main.ds.setSelected(sel);
     356        }
     357
     358        public void valueChanged(ListSelectionEvent e) {
     359            ListSelectionModel model = (ListSelectionModel)e.getSource();
     360            boolean enabled = model.getMinSelectionIndex() >= 0
     361            && model.getMaxSelectionIndex() >= model.getMinSelectionIndex();
     362            setEnabled(enabled);
    222363        }
    223364    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/HistoryDialog.java

    r1709 r1750  
    4848import org.openstreetmap.josm.gui.history.HistoryBrowserDialog;
    4949import org.openstreetmap.josm.io.OsmApi;
     50import org.openstreetmap.josm.io.OsmApiException;
    5051import org.openstreetmap.josm.io.OsmServerHistoryReader;
    5152import org.openstreetmap.josm.io.OsmTransferException;
     
    233234        if (task.getLastException() != null) {
    234235            task.getLastException().printStackTrace();
    235             String msg = task.getLastException().getMessage();
     236            String msg = null;
     237            if (task.getLastException() instanceof OsmApiException) {
     238                msg = ((OsmApiException)task.getLastException()).getErrorBody();
     239                if (msg == null) {
     240                    msg = ((OsmApiException)task.getLastException()).getErrorHeader();
     241                }
     242            }
     243            if (msg == null) {
     244                msg = task.getLastException().getMessage();
     245            }
    236246            if (msg == null) {
    237247                msg = task.getLastException().toString();
     
    452462            } catch(OsmTransferException e) {
    453463                lastException = e;
    454                 throw e;
     464                return;
    455465            } finally {
    456466                setInterminateEnabled(false);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r1332 r1750  
    5353
    5454        public void actionPerformed(ActionEvent e) {
    55             if (e != null && !(e.getSource() instanceof AbstractButton))
     55            if (e != null && !(e.getSource() instanceof AbstractButton)) {
    5656                button.setSelected(!button.isSelected());
     57            }
    5758            Boolean selected = button.isSelected();
    5859            setVisible(selected);
    5960            Main.pref.put(prefname+".visible", selected);
    60             if(!selected && winadapter != null)
     61            if(!selected && winadapter != null) {
    6162                winadapter.windowClosing(null);
    62             else if (!Main.pref.getBoolean(action.prefname+".docked", true)) {
     63            } else if (!Main.pref.getBoolean(action.prefname+".docked", true)) {
    6364                EventQueue.invokeLater(new Runnable(){
    6465                    public void run() {
     
    174175                        setVisible(false);
    175176                        parent.add(ToggleDialog.this);
    176                         if(Main.pref.getBoolean(action.prefname+".visible"))
     177                        if(Main.pref.getBoolean(action.prefname+".visible")) {
    177178                            setVisible(true);
     179                        }
    178180                        titleBar.setVisible(true);
    179                         if(e != null)
     181                        if(e != null) {
    180182                            Main.pref.put(action.prefname+".docked", true);
     183                        }
    181184                    }
    182185                }));
     
    190193                    String[] b = bounds.split(",");
    191194                    f.setBounds(Integer.parseInt(b[0]),Integer.parseInt(b[1]),Integer.parseInt(b[2]),Integer.parseInt(b[3]));
    192                 } else
     195                } else {
    193196                    f.pack();
     197                }
    194198                Main.pref.put(action.prefname+".docked", false);
    195199                f.setVisible(true);
     
    241245    public void close()
    242246    {
    243         if(winadapter != null)
     247        if(winadapter != null) {
    244248            winadapter.windowClosing(null);
     249        }
    245250    }
    246251
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r1748 r1750  
    367367            RelationMember  m = clone.members.get(i);
    368368            if (m.member.incomplete)
    369             {
    370369                // TODO: emit some message that sorting failed
    371370                return;
    372             }
    373371            try
    374372            {
     
    765763                DataSet dataSet = reader.parseOsm();
    766764                if (dataSet != null) {
    767                     final MergeVisitor visitor = new MergeVisitor(Main.main
    768                             .editLayer().data, dataSet);
     765                    final MergeVisitor visitor = new MergeVisitor(Main.main.map.mapView.getEditLayer()
     766                            .data, dataSet);
    769767                    visitor.merge();
    770768
    771769                    // copy the merged layer's data source info
    772770                    for (DataSource src : dataSet.dataSources) {
    773                         Main.main.editLayer().data.dataSources.add(src);
    774                     }
    775                     Main.main.editLayer().fireDataChange();
     771                        Main.main.map.mapView.getEditLayer().data.dataSources.add(src);
     772                    }
     773                    Main.main.map.mapView.getEditLayer().fireDataChange();
    776774
    777775                    if (visitor.getConflicts().isEmpty())
    778776                        return;
    779777                    final ConflictDialog dlg = Main.map.conflictDialog;
    780                     dlg.add(visitor.getConflicts());
     778                    dlg.getConflicts().add(visitor.getConflicts());
    781779                    JOptionPane.showMessageDialog(Main.parent,
    782780                            tr("There were conflicts during import."));
  • trunk/src/org/openstreetmap/josm/gui/history/PointInTimeType.java

    r1709 r1750  
    22package org.openstreetmap.josm.gui.history;
    33
    4 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    54
    65/**
  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r1690 r1750  
    1919import java.awt.event.ActionEvent;
    2020import java.awt.geom.Area;
    21 import java.awt.geom.Rectangle2D;
    2221import java.awt.image.BufferedImage;
    2322import java.io.File;
     
    4241import org.openstreetmap.josm.actions.SaveAction;
    4342import org.openstreetmap.josm.actions.SaveAsAction;
     43import org.openstreetmap.josm.data.conflict.Conflict;
     44import org.openstreetmap.josm.data.conflict.ConflictCollection;
    4445import org.openstreetmap.josm.data.coor.EastNorth;
    4546import org.openstreetmap.josm.data.coor.LatLon;
     
    6061import org.openstreetmap.josm.data.osm.visitor.SimplePaintVisitor;
    6162import org.openstreetmap.josm.gui.MapView;
    62 import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
    6363import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
    6464import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
     
    7474 */
    7575public class OsmDataLayer extends Layer {
     76
     77    /** the global counter for created data layers */
     78    static private int dataLayerCounter = 0;
     79
     80    /**
     81     * Replies a new unique name for a data layer
     82     *
     83     * @return a new unique name for a data layer
     84     */
     85    static public String createNewName() {
     86        dataLayerCounter++;
     87        return tr("Data Layer {0}", dataLayerCounter);
     88    }
    7689
    7790    public final static class DataCountVisitor extends AbstractVisitor {
     
    114127     */
    115128    public final DataSet data;
     129
     130    /**
     131     * the collection of conflicts detected in this layer
     132     */
     133    private ConflictCollection conflicts;
    116134
    117135    /**
     
    159177        this.data = data;
    160178        this.setAssociatedFile(associatedFile);
     179        conflicts = new ConflictCollection();
    161180    }
    162181
     
    177196        boolean active = Main.map.mapView.getActiveLayer() == this;
    178197        boolean inactive = !active && Main.pref.getBoolean("draw.data.inactive_color", true);
    179         boolean virtual = !inactive && Main.map.mapView.useVirtualNodes();
     198        boolean virtual = !inactive && Main.map.mapView.isVirtualNodesEnabled();
    180199
    181200        // draw the hatched area for non-downloaded region. only draw if we're the active
     
    271290        Main.map.mapView.repaint();
    272291
    273         if (visitor.getConflicts().isEmpty())
    274             return;
    275         final ConflictDialog dlg = Main.map.conflictDialog;
    276         dlg.add(visitor.getConflicts());
    277         JOptionPane.showMessageDialog(Main.parent,tr("There were {0} conflicts during import.", visitor.getConflicts().size()));
    278         if (!dlg.isVisible()) {
    279             dlg.action.actionPerformed(new ActionEvent(this, 0, ""));
     292        int numNewConflicts = 0;
     293        for (Conflict c : visitor.getConflicts()) {
     294            if (!conflicts.hasConflict(c)) {
     295                numNewConflicts++;
     296                conflicts.add(c);
     297            }
     298        }
     299        if (numNewConflicts > 0) {
     300            JOptionPane.showMessageDialog(Main.parent,tr("There were {0} conflicts during import.", numNewConflicts));
    280301        }
    281302    }
     
    510531        return layer_bounds_point;
    511532    }
     533
     534    /**
     535     * replies the set of conflicts currently managed in this layer
     536     *
     537     * @return the set of conflicts currently managed in this layer
     538     */
     539    public ConflictCollection getConflicts() {
     540        return conflicts;
     541    }
    512542}
  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r1691 r1750  
    330330            String diffresult = sendRequest("POST", "changeset/" + changeset.id + "/upload", diff);
    331331            DiffResultReader.parseDiffResult(diffresult, list, processed, duv.getNewIdMap(), Main.pleaseWaitDlg);
     332        } catch(OsmTransferException e) {
     333            throw e;
    332334        } catch(Exception e) {
    333335            throw new OsmTransferException(e);
     
    443445
    444446                if (retCode != 200)
    445                     throw new OsmApiException(retCode,errorHeader,responseBody.toString());
     447                    throw new OsmApiException(retCode,errorHeader.trim(),responseBody.toString().trim());
    446448
    447449                return responseBody.toString();
  • trunk/src/org/openstreetmap/josm/io/OsmServerWriter.java

    r1691 r1750  
    9494        boolean useChangeset = Main.pref.getBoolean("osm-server.atomic-upload", apiVersion.compareTo("0.6")>=0);
    9595        if (useChangeset && ! canUseChangeset) {
    96             System.out.println(tr("WARNING: preference ''{0}'' or api version ''{1}'' of dataset requires to use changesets, but API is not handle them. Ignoring changesets.", "osm-server.atomic-upload", apiVersion));
     96            System.out.println(tr("WARNING: preference ''{0}'' or api version ''{1}'' of dataset requires to use changesets, but API is not able to handle them. Ignoring changesets.", "osm-server.atomic-upload", apiVersion));
    9797            useChangeset = false;
    9898        }
  • trunk/test/functional/org/openstreetmap/josm/io/MultiFetchServerObjectReaderTest.java

    r1703 r1750  
    5757        for (int i=0; i< numNodes; i++) {
    5858            Node n = new Node(0);
    59             n.coor = new LatLon(-36.6,47.6); // somewhere in the atlantic
     59            n.setCoor(new LatLon(-36.6,47.6));
    6060            n.put("name", "node-"+i);
    6161            n.incomplete = false;
  • trunk/test/unit/org/openstreetmap/josm/data/osm/history/HistoryWayTest.java

    r1670 r1750  
    102102
    103103        assertEquals(2, ids.size());
    104         assertEquals(1, ids.get(0));
    105         assertEquals(2, ids.get(1));
     104        assertEquals(1, (long) ids.get(0));
     105        assertEquals(2, (long) ids.get(1));
    106106    }
    107107
  • trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java

    r1707 r1750  
    722722        Way merged = (Way)my.getPrimitiveById(3);
    723723        assertEquals(1,visitor.getConflicts().size());
    724         assertEquals(true, visitor.getConflicts().keySet().contains(myWay));
    725         assertEquals(true, visitor.getConflicts().values().contains(theirWay));
     724        assertEquals(true, visitor.getConflicts().hasConflictForMy(myWay));
     725        assertEquals(true, visitor.getConflicts().hasConflictForTheir(theirWay));
    726726        assertEquals(myWay,merged);
    727727    }
Note: See TracChangeset for help on using the changeset viewer.