Diff [2024:2060] for / – JOSM

/trunk/presets/presets.xml

-              r2024
+              r2060
             <label text="Edit Hunting Stand" />
             <key key="amenity" value="hunting_stand" />
-            <check key="shelter" text="Shelter" default="off" delete_if_empty="true" />
-            <check key="hide" text="Hide" default="off" delete_if_empty="true" />
-            <check key="lock" text="Lock" default="off" delete_if_empty="true" />
             <combo key="height" text="Height" values="low,half,full,5,10,15,20" default="" delete_if_empty="true" />
+            <combo key="shelter" text="Shelter" values="yes,no,unknown" default="" delete_if_empty="true" />
+            <combo key="hide" text="Hide" values="yes,no,unknown" default="" delete_if_empty="true" />
+            <combo key="lock" text="Lock" values="yes,no,unknown" default="" delete_if_empty="true" />
         </item>
         <item name="Fountain" icon="presets/spring.png" type="node,closedway">
 …
             <key key="amenity" value="bank" />
             <text key="name" text="Name" default="" delete_if_empty="true" />
+            <text key="operator" text="Operator" default="" delete_if_empty="true" />
             <combo key="opening_hours" text="Opening Hours" values="24/7,Mo-Fr 08:30-20:00,Tu-Su 08:00-15:00; Sa 08:00-12:00" default="" delete_if_empty="true" />
             <check key="atm" text="Automated Teller Machine" default="on" delete_if_empty="true" />

/trunk/src/org/openstreetmap/josm/Main.java

-              r2024
+              r2060
 package org.openstreetmap.josm;
 import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trn;
 import java.awt.BorderLayout;
 …
 import java.awt.event.KeyEvent;
 import java.io.File;
+import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
 import java.util.StringTokenizer;
 …
 import javax.swing.JComponent;
 import javax.swing.JFrame;
+import javax.swing.JLabel;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.UIManager;
+import org.openstreetmap.josm.actions.OpenFileAction;
 import org.openstreetmap.josm.actions.SaveAction;
 import org.openstreetmap.josm.actions.downloadtasks.DownloadGpsTask;
 …
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
 import org.openstreetmap.josm.gui.download.DownloadDialog.DownloadTask;
+import org.openstreetmap.josm.gui.io.SaveLayersDialog;
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
         //
         try {
+            CoordinateFormat format = CoordinateFormat.valueOf(Main.pref.get("coordinates"));
+            //CoordinateFormat format = CoordinateFormat.valueOf(Main.pref.get("coordinates"));
             CoordinateFormat.setCoordinateFormat(CoordinateFormat.valueOf(Main.pref.get("coordinates")));
         } catch (IllegalArgumentException iae) {
 …
+    }
+    public static boolean breakBecauseUnsavedChanges() {
+    public static boolean saveUnsavedModifications() {
+        if (map == null) return true;
+        SaveLayersDialog dialog = new SaveLayersDialog(Main.parent);
+        List<OsmDataLayer> layersWithUnmodifiedChanges = new ArrayList<OsmDataLayer>();
+        for (OsmDataLayer l: Main.map.mapView.getLayersOfType(OsmDataLayer.class)) {
+            if (l.requiresSaveToFile() || l.requiresUploadToServer()) {
+                layersWithUnmodifiedChanges.add(l);
+            }
+        }
+        dialog.prepareForSavingAndUpdatingLayersBeforeExit();
+        if (!layersWithUnmodifiedChanges.isEmpty()) {
+            dialog.getModel().populate(layersWithUnmodifiedChanges);
+            dialog.setVisible(true);
+            switch(dialog.getUserAction()) {
+                case CANCEL: return false;
+                case PROCEED: return true;
+                default: return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Saves all {@see OsmDataLayer}s with an associated file and with unsaved
+     * data modifications.
+     *
+     * @return true, if the save operation was successful; false, otherwise
+     */
+    public static boolean saveUnsavedModifications_old() {
         Shortcut.savePrefs();
+        if (map != null) {
+            boolean modified = false;
+            boolean uploadedModified = false;
+            for (final Layer l : map.mapView.getAllLayers()) {
+                if (l instanceof OsmDataLayer && ((OsmDataLayer)l).isModified()) {
+                    modified = true;
+                    uploadedModified = ((OsmDataLayer)l).uploadedModified;
+                    break;
+                }
+            }
+            if (modified) {
+                final String msg = uploadedModified ? "\n"
+                        +tr("Hint: Some changes came from uploading new data to the server.") : "";
+                        int result = new ExtendedDialog(parent, tr("Unsaved Changes"),
+                                new javax.swing.JLabel(tr("There are unsaved changes. Discard the changes and continue?")+msg),
+                                new String[] {tr("Save and Exit"), tr("Discard and Exit"), tr("Cancel")},
+                                new String[] {"save.png", "exit.png", "cancel.png"}).getValue();
+                        // Save before exiting
+                        if(result == 1) {
+                            Boolean savefailed = false;
+                            for (final Layer l : map.mapView.getAllLayers()) {
+                                if (l instanceof OsmDataLayer && ((OsmDataLayer)l).isModified()) {
+                                    SaveAction save = new SaveAction();
+                                    if(!save.doSave(l)) {
+                                        savefailed = true;
+                                    }
+                                }
+                            }
+                            return savefailed;
+                        }
+                        else if(result != 2) // Cancel exiting unless the 2nd button was clicked
+                            return true;
+            }
+        }
+        return false;
+        if (map == null)
+            return true; // nothing to save, return success
+        int numUnsavedLayers = 0;
+        for (final OsmDataLayer l : map.mapView.getLayersOfType(OsmDataLayer.class)) {
+            if (l.requiresSaveToFile()) {
+                numUnsavedLayers++;
+            }
+        }
+        if (numUnsavedLayers == 0)
+            return true; // nothing to save, return success
+        String msg = trn(
+                "There are unsaved changes in {0} layer. Discard the changes and continue?",
+                "There are unsaved changes in {0} layers. Discard the changes and continue?",
+                numUnsavedLayers,
+                numUnsavedLayers
+        );
+        ExtendedDialog ed = new ExtendedDialog(parent,
+                tr("Unsaved Changes"),
+                new String[] {tr("Save and Exit"), tr("Discard and Exit"), tr("Cancel")});
+        ed.setButtonIcons(new String[] {"save.png", "exit.png", "cancel.png"});
+        ed.setContent(new JLabel(msg));
+        ed.showDialog();
+        switch(ed.getValue()) {
+            case 2: /* discard and exit */ return true;
+            case 3: /* cancel */ return false;
+        }
+        boolean savefailed = false;
+        for (OsmDataLayer l : map.mapView.getLayersOfType(OsmDataLayer.class)) {
+            if(!new SaveAction().doSave(l)) {
+                savefailed = true;
+            }
+        }
+        return !savefailed;
+    }
 …
         if (s.startsWith("file:")) {
+            File f = null;
             try {
                 main.menu.openFile.openFile(new File(new URI(s)));
+                f = new File(new URI(s));
             } catch (URISyntaxException e) {
                 JOptionPane.showMessageDialog(
 …
                 );
+            }
+            try {
+                if (f!=null) {
+                    OpenFileAction.openFile(f);
+                }
+            }catch(IOException e) {
+                e.printStackTrace();
+                JOptionPane.showMessageDialog(
+                        Main.parent,
+                        tr("<html>Could not read file ''{0}\''.<br> Error is: <br>{1}</html>", f.getName(), e.getMessage()),
+                        tr("Error"),
+                        JOptionPane.ERROR_MESSAGE
+                );
+            }
             return;
+        }
 …
+            }
+        }
+        main.menu.openFile.openFile(new File(s));
+        File f = new File(s);
+        try {
+            OpenFileAction.openFile(f);
+        }catch(IOException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("<html>Could not read file ''{0}\''.<br> Error is: <br>{1}</html>", f.getName(), e.getMessage()),
+                    tr("Error"),
+                    JOptionPane.ERROR_MESSAGE
+            );
+        }
+    }

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

-              r2024
+              r2060
 import java.awt.event.ActionEvent;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Iterator;
 …
      * @return the base URL, i.e. http://api.openstreetmap.org/browse
      */
     protected String getBaseURL() {
+    static public String getBaseBrowseUrl() {
         String baseUrl = Main.pref.get("osm-server.url", "http://api.openstreetmap.org/api");
         Pattern pattern = Pattern.compile("/api/?$");
         String ret =  pattern.matcher(baseUrl).replaceAll("/browse");
         if (ret.equals(baseUrl)) {
+            System.out.println(tr("WARNING: unexpected format of API base URL. Redirection to history page for OSM primitive will probably fail. API base URL is: ''{0}''",baseUrl));
+            System.out.println(tr("WARNING: unexpected format of API base URL. Redirection to info or history page for OSM primitive will probably fail. API base URL is: ''{0}''",baseUrl));
+        }
         if (ret.startsWith("http://api.openstreetmap.org/")) {
 …
+    }
+    protected void launchBrowser() {
+    /**
+     * replies the base URL for browsing information about a user
+     *
+     * @return the base URL, i.e. http://ww.openstreetmap.org/user
+     */
+    static public String getBaseUserUrl() {
+        String baseUrl = Main.pref.get("osm-server.url", "http://api.openstreetmap.org/api");
+        Pattern pattern = Pattern.compile("/api/?$");
+        String ret =  pattern.matcher(baseUrl).replaceAll("/user");
+        if (ret.equals(baseUrl)) {
+            System.out.println(tr("WARNING: unexpected format of API base URL. Redirection to user page for OSM user will probably fail. API base URL is: ''{0}''",baseUrl));
+        }
+        if (ret.startsWith("http://api.openstreetmap.org/")) {
+            ret = ret.substring("http://api.openstreetmap.org/".length());
+            ret = "http://www.openstreetmap.org/" + ret;
+        }
+        return ret;
+    }
+    protected void launchBrowser(URL url) {
+        OpenBrowser.displayUrl(
+                url.toString()
+        );
+    }
+    protected void launchBrowser(String url) {
+        OpenBrowser.displayUrl(
+                url
+        );
+    }
+    protected void launchInfoBrowsersForSelectedPrimitives() {
         ArrayList<OsmPrimitive> primitivesToShow = new ArrayList<OsmPrimitive>(getCurrentDataSet().getSelected());
 …
         Iterator<OsmPrimitive> it = primitivesToShow.iterator();
         while(it.hasNext()) {
             if (it.next().id == 0) {
+            if (it.next().getId() == 0) {
                 it.remove();
+            }
 …
+        }
         for(int i = 0; i < max; i++) {
+            OpenBrowser.displayUrl(
+                    createInfoUrl(primitivesToShow.get(i))
+            );
+            launchBrowser(createInfoUrl(primitivesToShow.get(i)));
+        }
+    }
     public void actionPerformed(ActionEvent e) {
         launchBrowser();
+        launchInfoBrowsersForSelectedPrimitives();
+    }
     protected abstract String createInfoUrl(OsmPrimitive primitive);
+    protected abstract String createInfoUrl(Object infoObject);
     @Override

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

-              r2024
+              r2060
         layerList.setModel(new DefaultComboBoxModel(targetLayers.toArray()));
         layerList.setSelectedIndex(0);
         JPanel pnl = new JPanel();
         pnl.setLayout(new GridBagLayout());
         pnl.add(new JLabel(tr("Please select the target layer.")), GBC.eol());
         pnl.add(layerList, GBC.eol());
+        int decision = new ExtendedDialog(Main.parent, tr("Select target layer"), pnl, new String[] { tr("Merge"),
+            tr("Cancel") }, new String[] { "dialogs/mergedown", "cancel" }).getValue();
+        if (decision != 1)
+        ExtendedDialog ed = new ExtendedDialog(Main.parent,
+                tr("Select target layer"),
+                new String[] { tr("Merge"), tr("Cancel") });
+        ed.setButtonIcons(new String[] { "dialogs/mergedown", "cancel" });
+        ed.setContent(pnl);
+        ed.showDialog();
+        if (ed.getValue() != 1)
             return null;
         Layer targetLayer = (Layer) layerList.getSelectedItem();
         return targetLayer;

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

-              r2024
+              r2060
-// License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.actions;
 …
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.ExceptionDialogUtil;
+import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
 import org.openstreetmap.josm.io.OsmApi;
 import org.openstreetmap.josm.io.OsmApiInitializationException;
 …
         OsmApi api = OsmApi.getOsmApi();
         try {
+            api.initialize();
+            api.initialize(NullProgressMonitor.INSTANCE);
             long maxNodes = 0;
             if (api.getCapabilities().isDefined("waynodes", "maximum")) {
 …
             for (Entry<String,String> e : osmPrimitive.entrySet()) {
                 if(e.getValue().length() > 255) {
                     if (osmPrimitive.deleted) {
+                    if (osmPrimitive.isDeleted()) {
                         // if OsmPrimitive is going to be deleted we automatically shorten the
                         // value
 …
                                 tr("Warning: automatically truncating value of tag ''{0}'' on deleted primitive {1}",
                                         e.getKey(),
                                         Long.toString(osmPrimitive.id)
+                                        Long.toString(osmPrimitive.getId())
+                                )
                         );
 …
                     JOptionPane.showMessageDialog(Main.parent,
                             tr("Length of value for tag ''{0}'' on primitive {1} exceeds the max. allowed length {2}. Values length is {3}.",
                                     e.getKey(), Long.toString(osmPrimitive.id), 255, e.getValue().length()
+                                    e.getKey(), Long.toString(osmPrimitive.getId()), 255, e.getValue().length()
                             ),
                             tr("Precondition Violation"),
 …
                         tr("{0} nodes in way {1} exceed the max. allowed number of nodes {2}",
                                 ((Way)osmPrimitive).getNodesCount(),
                                 Long.toString(osmPrimitive.id),
+                                Long.toString(osmPrimitive.getId()),
                                 maxNodes
                         ),

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

-              r2024
+              r2060
         HashSet<Relation> relationsUsingWays = new HashSet<Relation>();
         for (Relation r : getCurrentDataSet().relations) {
             if (r.deleted || r.incomplete) {
+            if (r.isDeleted() || r.incomplete) {
                 continue;
+            }
 …
         for (HashSet<Way> waylinks : backlinks.values()) {
             if (!waylinks.containsAll(selectedWays)) {
+                int option = new ExtendedDialog(Main.parent,
+                ExtendedDialog ed = new ExtendedDialog(Main.parent,
                         tr("Combine ways with different memberships?"),
+                        tr("The selected ways have differing relation memberships.  "
+                                + "Do you still want to combine them?"),
+                                new String[] {tr("Combine Anyway"), tr("Cancel")},
+                                new String[] {"combineway.png", "cancel.png"}).getValue();
+                if (option == 1) {
+                        new String[] {tr("Combine Anyway"), tr("Cancel")});
+                ed.setButtonIcons(new String[] {"combineway.png", "cancel.png"});
+                ed.setContent(tr("The selected ways have differing relation memberships.  "
+                        + "Do you still want to combine them?"));
+                ed.showDialog();
+                if (ed.getValue() == 1) {
                     break;
+                }
 …
             Object secondTry = actuallyCombineWays(selectedWays, true);
             if (secondTry instanceof List<?>) {
                 int option = new ExtendedDialog(Main.parent,
+                ExtendedDialog ed = new ExtendedDialog(Main.parent,
                         tr("Change directions?"),
+                        tr("The ways can not be combined in their current directions.  "
+                                + "Do you want to reverse some of them?"),
+                                new String[] {tr("Reverse and Combine"), tr("Cancel")},
+                                new String[] {"wayflip.png", "cancel.png"}).getValue();
+                if (option != 1) return;
+                        new String[] {tr("Reverse and Combine"), tr("Cancel")});
+                ed.setButtonIcons(new String[] {"wayflip.png", "cancel.png"});
+                ed.setContent(tr("The ways can not be combined in their current directions.  "
+                        + "Do you want to reverse some of them?"));
+                ed.showDialog();
+                if (ed.getValue() != 1) return;
                 nodeList = (List<Node>) secondTry;
             } else {
 …
         for (Way w : selectedWays) {
             modifyWay = w;
             if (w.id != 0) {
+            if (w.getId() != 0) {
                 break;
+            }
 …
         if (!components.isEmpty()) {
+            int answer = new ExtendedDialog(Main.parent,
+            ExtendedDialog ed = new ExtendedDialog(Main.parent,
                     tr("Enter values for all conflicts."),
+                    p,
+                    new String[] {tr("Solve Conflicts"), tr("Cancel")},
+                    new String[] {"dialogs/conflict.png", "cancel.png"}).getValue();
+            if (answer != 1) return;
+                    new String[] {tr("Solve Conflicts"), tr("Cancel")});
+            ed.setButtonIcons(new String[] {"dialogs/conflict.png", "cancel.png"});
+            ed.setContent(p);
+            ed.showDialog();
+            if (ed.getValue() != 1) return;
             for (Entry<String, JComboBox> e : components.entrySet()) {

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

-              r2024
+              r2060
 import javax.swing.JFileChooser;
-import javax.swing.filechooser.FileFilter;
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.gui.ExtendedDialog;
-import org.openstreetmap.josm.io.FileImporter;
 import org.openstreetmap.josm.tools.Shortcut;
 …
         fc.setMultiSelectionEnabled(multiple);
         fc.setAcceptAllFileFilterUsed(false);
+        FileFilter defaultFilter = null;
+        for (FileImporter imExporter: ExtensionFileFilter.importers) {
+            fc.addChoosableFileFilter(imExporter.filter);
+            if (extension != null && extension.endsWith(imExporter.filter.defaultExtension)) {
+                defaultFilter = imExporter.filter;
+            }
+        }
+        if (defaultFilter == null) {
+            defaultFilter = new ExtensionFileFilter.AllFormatsImporter().filter;
+        }
+        fc.setFileFilter(defaultFilter);
+        System.out.println("opening fc for extension " + extension);
+        ExtensionFileFilter.applyChoosableImportFileFilters(fc, extension);
         int answer = open ? fc.showOpenDialog(Main.parent) : fc.showSaveDialog(Main.parent);

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

-              r2024
+              r2060
     public ExitAction() {
         super(tr("Exit"), "exit", tr("Exit the application."),
+        Shortcut.registerShortcut("system:menuexit", tr("Exit"), KeyEvent.VK_Q, Shortcut.GROUP_MENU), true);
+                Shortcut.registerShortcut("system:menuexit", tr("Exit"), KeyEvent.VK_Q, Shortcut.GROUP_MENU), true);
+    }
     public void actionPerformed(ActionEvent e) {
         if (!Main.breakBecauseUnsavedChanges()) {
+        if (Main.saveUnsavedModifications()) {
             Main.saveGuiGeometry();
             System.exit(0);

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

-              r2024
+              r2060
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import javax.swing.JFileChooser;
 import javax.swing.filechooser.FileFilter;
 …
  * filters used in JOSM.
+ *
- * @author imi
  */
 public class ExtensionFileFilter extends FileFilter {
-    private final String extension;
-    private final String description;
-    public final String defaultExtension;
     /**
 …
     public static ArrayList<FileExporter> exporters = new ArrayList<FileExporter>(Arrays.asList(new GpxExporter(),
             new OsmExporter(), new OsmGzipExporter(), new OsmBzip2Exporter()));
+    private final String extensions;
+    private final String description;
+    /**
+     * @deprecated use {@see #getDefaultExtension()
+     */
+    @Deprecated
+    public final String defaultExtension;
+    static protected void sort(List<ExtensionFileFilter> filters) {
+        Collections.sort(
+                filters,
+                new Comparator<ExtensionFileFilter>() {
+                    private AllFormatsImporter all = new AllFormatsImporter();
+                    public int compare(ExtensionFileFilter o1, ExtensionFileFilter o2) {
+                        if (o1.getDescription().equals(all.filter.getDescription())) return 1;
+                        if (o2.getDescription().equals(all.filter.getDescription())) return -1;
+                        return o1.getDescription().compareTo(o2.getDescription());
+                    }
+                }
+        );
+    }
+    /**
+     * Replies an ordered list of {@see ExtensionFileFilter}s for importing.
+     * The list is ordered according to their description, an {@see AllFormatsImporter}
+     * is append at the end.
+     *
+     * @return an ordered list of {@see ExtensionFileFilter}s for importing.
+     */
+    public static List<ExtensionFileFilter> getImportExtensionFileFilters() {
+        LinkedList<ExtensionFileFilter> filters = new LinkedList<ExtensionFileFilter>();
+        for (FileImporter importer : importers) {
+            if (filters.contains(importer.filter)) {
+                continue;
+            }
+            filters.add(importer.filter);
+        }
+        sort(filters);
+        return filters;
+    }
+    /**
+     * Replies an ordered list of {@see ExtensionFileFilter}s for exporting.
+     * The list is ordered according to their description, an {@see AllFormatsImporter}
+     * is append at the end.
+     *
+     * @return an ordered list of {@see ExtensionFileFilter}s for exporting.
+     */
+    public static List<ExtensionFileFilter> getExportExtensionFileFilters() {
+        LinkedList<ExtensionFileFilter> filters = new LinkedList<ExtensionFileFilter>();
+        for (FileExporter exporter : exporters) {
+            if (filters.contains(exporter.filter)) {
+                continue;
+            }
+            filters.add(exporter.filter);
+        }
+        sort(filters);
+        return filters;
+    }
+    /**
+     * Replies the default {@see ExtensionFileFilter} for a given extension
+     *
+     * @param extension the extension
+     * @return the default {@see ExtensionFileFilter} for a given extension
+     */
+    public static ExtensionFileFilter getDefaultImportExtensionFileFilter(String extension) {
+        if (extension == null) return new AllFormatsImporter().filter;
+        for (FileImporter importer : importers) {
+            if (extension.equals(importer.filter.getDefaultExtension()))
+                return importer.filter;
+        }
+        return new AllFormatsImporter().filter;
+    }
+    /**
+     * Replies the default {@see ExtensionFileFilter} for a given extension
+     *
+     * @param extension the extension
+     * @return the default {@see ExtensionFileFilter} for a given extension
+     */
+    public static ExtensionFileFilter getDefaultExportExtensionFileFilter(String extension) {
+        if (extension == null) return new AllFormatsImporter().filter;
+        for (FileExporter exporter : exporters) {
+            if (extension.equals(exporter.filter.getDefaultExtension()))
+                return exporter.filter;
+        }
+        return new AllFormatsImporter().filter;
+    }
+    /**
+     * Applies the choosable {@see FileFilter} to a {@see JFileChooser} before using the
+     * file chooser for selecting a file for reading.
+     *
+     * @param fileChooser the file chooser
+     * @param extension the default extension
+     */
+    public static void applyChoosableImportFileFilters(JFileChooser fileChooser, String extension) {
+        for (ExtensionFileFilter filter: getImportExtensionFileFilters()) {
+            fileChooser.addChoosableFileFilter(filter);
+        }
+        fileChooser.setFileFilter(getDefaultImportExtensionFileFilter(extension));
+    }
+    /**
+     * Applies the choosable {@see FileFilter} to a {@see JFileChooser} before using the
+     * file chooser for selecting a file for writing.
+     *
+     * @param fileChooser the file chooser
+     * @param extension the default extension
+     */
+    public static void applyChoosableExportFileFilters(JFileChooser fileChooser, String extension) {
+        for (ExtensionFileFilter filter: getExportExtensionFileFilters()) {
+            fileChooser.addChoosableFileFilter(filter);
+        }
+        fileChooser.setFileFilter(getDefaultExportExtensionFileFilter(extension));
+    }
     /**
      * Construct an extension file filter by giving the extension to check after.
      */
     public ExtensionFileFilter(String extension, String defExt, String description) {
+        this.extension = extension;
         defaultExtension = defExt;
+    public ExtensionFileFilter(String extension, String defaultExtension, String description) {
+        this.extensions = extension;
+        this.defaultExtension = defaultExtension;
         this.description = description;
+    }
 …
     public boolean acceptName(String filename) {
         String name = filename.toLowerCase();
+        for (String ext : extension.split(","))
+        for (String ext : extensions.split(","))
             if (name.endsWith("."+ext))
                 return true;
 …
         return description;
+    }
+    public String getDefaultExtension() {
+        return defaultExtension;
+    }
     /**
      * Dummy importer that adds the "All Formats"-Filter when opening files
 …
         public AllFormatsImporter() {
             super(
+                new ExtensionFileFilter("osm,xml,osm.gz,osm.bz2,osm.bz,gpx,gpx.gz,nmea,nme,nma,txt", "", tr("All Formats")
+                        + " (*.gpx *.osm *.nmea ...)"));
+                    new ExtensionFileFilter("osm,xml,osm.gz,osm.bz2,osm.bz,gpx,gpx.gz,nmea,nme,nma,txt,wms", "", tr("All Formats")
+                            + " (*.gpx *.osm *.nmea ...)"));
+        }
         @Override public boolean acceptFile(File pathname) {
 …
+        }
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((defaultExtension == null) ? 0 : defaultExtension.hashCode());
+        result = prime * result + ((description == null) ? 0 : description.hashCode());
+        result = prime * result + ((extensions == null) ? 0 : extensions.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        ExtensionFileFilter other = (ExtensionFileFilter) obj;
+        if (defaultExtension == null) {
+            if (other.defaultExtension != null)
+                return false;
+        } else if (!defaultExtension.equals(other.defaultExtension))
+            return false;
+        if (description == null) {
+            if (other.description != null)
+                return false;
+        } else if (!description.equals(other.description))
+            return false;
+        if (extensions == null) {
+            if (other.extensions != null)
+                return false;
+        } else if (!extensions.equals(other.extensions))
+            return false;
+        return true;
+    }
+}

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

r2024	r2060
20	20
21	21	@Override
22		protected String createInfoUrl(OsmPrimitive primitive) {
23		return getBaseURL() + "/" + OsmPrimitiveType.from(primitive).getAPIName() + "/" + primitive.id + "/history";
	22	protected String createInfoUrl(Object infoObject) {
	23	OsmPrimitive primitive = (OsmPrimitive)infoObject;
	24	return getBaseBrowseUrl() + "/" + OsmPrimitiveType.from(primitive).getAPIName() + "/" + primitive.getId() + "/history";
24	25	}
25	26	}

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

r2024	r2060
20	20
21	21	@Override
22		protected String createInfoUrl(OsmPrimitive primitive) {
23		return getBaseURL() + "/" + OsmPrimitiveType.from(primitive).getAPIName() + "/" + primitive.id;
	22	protected String createInfoUrl(Object infoObject) {
	23	OsmPrimitive primitive = (OsmPrimitive)infoObject;
	24	return getBaseBrowseUrl() + "/" + OsmPrimitiveType.from(primitive).getAPIName() + "/" + primitive.getId();
24	25	}
25	26	}

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

-              r2024
+              r2060
         Node useNode = null;
         for (Node n: selectedNodes) {
             if (n.id > 0) {
+            if (n.getId() > 0) {
                 useNode = n;
                 break;
 …
         HashSet<Relation> relationsUsingNodes = new HashSet<Relation>();
         for (Relation r : getCurrentDataSet().relations) {
             if (r.deleted || r.incomplete) {
+            if (r.isDeleted() || r.incomplete) {
                 continue;
+            }
 …
         for (HashSet<Node> nodelinks : backlinks.values()) {
             if (!nodelinks.containsAll(allNodes)) {
                 int option = new ExtendedDialog(Main.parent,
+                ExtendedDialog ed = new ExtendedDialog(Main.parent,
                         tr("Merge nodes with different memberships?"),
+                        tr("The selected nodes have differing relation memberships.  "
+                                + "Do you still want to merge them?"),
+                                new String[] {tr("Merge Anyway"), tr("Cancel")},
+                                new String[] {"mergenodes.png", "cancel.png"}).getValue();
+                if (option == 1) {
+                        new String[] {tr("Merge Anyway"), tr("Cancel")});
+                ed.setButtonIcons(new String[] {"mergenodes.png", "cancel.png"});
+                ed.setContent(tr("The selected nodes have differing relation memberships.  "
+                        + "Do you still want to merge them?"));
+                ed.showDialog();
+                if (ed.getValue() == 1) {
                     break;
+                }
 …
         for (Way w : getCurrentDataSet().ways) {
             if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
+            if (w.isDeleted() || w.incomplete || w.getNodesCount() < 1) {
                 continue;
+            }

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

-              r2024
+              r2060
 import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
 import javax.swing.JFileChooser;
 …
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.io.FileImporter;
+import org.openstreetmap.josm.io.OsmTransferException;
 import org.openstreetmap.josm.tools.Shortcut;
+import org.xml.sax.SAXException;
 /**
 …
             return;
         File[] files = fc.getSelectedFiles();
+        for (int i = files.length; i > 0; --i) {
+            openFile(files[i-1]);
+        }
+    }
+    /**
+     * Open the given file.
+     */
+    public void openFile(File file) {
+        try {
+            System.out.println("Open file: " + file.getAbsolutePath() + " (" + file.length() + " bytes)");
+            for (FileImporter importer : ExtensionFileFilter.importers)
+                if (importer.acceptFile(file)) {
+                    importer.importData(file);
+                }
+        } catch (IOException x) {
+            x.printStackTrace();
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("<html>Could not read file ''{0}\''. Error is: <br>{1}</html>", file.getName(), x.getMessage()),
+                    tr("Error"),
+                    JOptionPane.ERROR_MESSAGE
+            );
+        }
+        OpenFileTask task = new OpenFileTask(Arrays.asList(files));
+        Main.worker.submit(task);
+    }
 …
         setEnabled(! Main.applet);
+    }
+    static public void openFile(File f) throws IOException {
+        for (FileImporter importer : ExtensionFileFilter.importers)
+            if (importer.acceptFile(f)) {
+                importer.importData(f);
+            }
+    }
+    static public class OpenFileTask extends PleaseWaitRunnable {
+        private List<File> files;
+        private boolean cancelled;
+        public OpenFileTask(List<File> files) {
+            super(tr("Opening files"), false /* don't ignore exception */);
+            this.files = files;
+        }
+        @Override
+        protected void cancel() {
+            this.cancelled = true;
+        }
+        @Override
+        protected void finish() {
+            // do nothing
+        }
+        @Override
+        protected void realRun() throws SAXException, IOException, OsmTransferException {
+            if (files == null || files.isEmpty()) return;
+            getProgressMonitor().setTicks(files.size());
+            for (File f : files) {
+                if (cancelled) return;
+                getProgressMonitor().subTask(tr("Opening file ''{0}'' ...", f.getAbsolutePath()));
+                try {
+                    System.out.println("Open file: " + f.getAbsolutePath() + " (" + f.length() + " bytes)");
+                    openFile(f);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    JOptionPane.showMessageDialog(
+                            Main.parent,
+                            tr("<html>Could not read file ''{0}\''.<br> Error is: <br>{1}</html>", f.getName(), e.getMessage()),
+                            tr("Error"),
+                            JOptionPane.ERROR_MESSAGE
+                    );
+                }
+                getProgressMonitor().worked(1);
+            }
+        }
+    }
+}

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

-              r2024
+              r2060
     protected Map<OsmPrimitiveType, Integer> getSourceStatistics() {
         HashMap<OsmPrimitiveType, Integer> ret = new HashMap<OsmPrimitiveType, Integer>();
+        for (Class type: new Class[] {Node.class, Way.class, Relation.class}) {
+        for (Class<? extends OsmPrimitive> type: new Class[] {Node.class, Way.class, Relation.class}) {
             if (!getSourceTagsByType(type).isEmpty()) {
                 ret.put(OsmPrimitiveType.from(type), getSourcePrimitivesByType(type).size());
 …
     protected Map<OsmPrimitiveType, Integer> getTargetStatistics() {
         HashMap<OsmPrimitiveType, Integer> ret = new HashMap<OsmPrimitiveType, Integer>();
+        for (Class type: new Class[] {Node.class, Way.class, Relation.class}) {
+        for (Class<? extends OsmPrimitive> type: new Class[] {Node.class, Way.class, Relation.class}) {
             int count = getSubcollectionByType(getEditLayer().data.getSelected(), type).size();
             if (count > 0) {
 …
     protected void pasteFromHomogeneousSource(Collection<? extends OsmPrimitive> targets) {
         TagCollection tc = null;
+        Class sourceType = null;
+        for (Class type : new Class[] {Node.class, Way.class, Relation.class}) {
+        for (Class<? extends OsmPrimitive> type : new Class[] {Node.class, Way.class, Relation.class}) {
             TagCollection tc1 = getSourceTagsByType(type);
             if (!tc1.isEmpty()) {
                 tc = tc1;
-                sourceType = type;
+            }
+        }

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

-              r2024
+              r2060
             layer.setName(file.getName());
             layer.setAssociatedFile(file);
+            if (layer instanceof OsmDataLayer) {
+                ((OsmDataLayer) layer).onPostSaveToFile();
+            }
             Main.parent.repaint();
         } catch (IOException e) {
 …
      */
     public boolean checkSaveConditions(Layer layer) {
-        if (layer == null) {
-            JOptionPane.showMessageDialog(
-                    Main.parent,
-                    tr("Internal Error: cannot check conditions for no layer. Please report this as a bug."),
-                    tr("Error"),
-                    JOptionPane.ERROR_MESSAGE
-            );
-            return false;
+        }
-        if (Main.map == null) {
-            JOptionPane.showMessageDialog(
-                    Main.parent,
-                    tr("No document open so nothing to save."),
-                    tr("Warning"),
-                    JOptionPane.WARNING_MESSAGE
-            );
-            return false;
+        }
         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())
             return false;
 …
     public static File openFileDialog(Layer layer) {
         if (layer instanceof OsmDataLayer)
             return createAndOpenSaveFileChooser(tr("Save OSM file"), ".osm");
+            return createAndOpenSaveFileChooser(tr("Save OSM file"), "osm");
         else if (layer instanceof GpxLayer)
             return createAndOpenSaveFileChooser(tr("Save GPX file"), ".gpx");
         return createAndOpenSaveFileChooser(tr("Save Layer"), ".lay");
+            return createAndOpenSaveFileChooser(tr("Save GPX file"), "gpx");
+        return createAndOpenSaveFileChooser(tr("Save Layer"), "lay");
+    }
 …
     private boolean isDataSetEmpty(OsmDataLayer layer) {
         for (OsmPrimitive osm : layer.data.allNonDeletedPrimitives())
             if (!osm.deleted || osm.id > 0)
+            if (!osm.isDeleted() || osm.getId() > 0)
                 return false;
         return true;
 …
         fc.setMultiSelectionEnabled(false);
         fc.setAcceptAllFileFilterUsed(false);
+        FileFilter defaultFilter = null;
+        for (FileExporter exporter : ExtensionFileFilter.exporters) {
+            fc.addChoosableFileFilter(exporter.filter);
+            if (extension.endsWith(exporter.filter.defaultExtension)) {
+                defaultFilter = exporter.filter;
+            }
+        }
+        if (defaultFilter != null) {
+            fc.setFileFilter(defaultFilter);
+        }
+        ExtensionFileFilter.applyChoosableExportFileFilters(fc, extension);
         int answer = fc.showSaveDialog(Main.parent);
         if (answer != JFileChooser.APPROVE_OPTION)
 …
                 FileFilter ff = fc.getFileFilter();
                 if (ff instanceof ExtensionFileFilter) {
                     fn += "." + ((ExtensionFileFilter)ff).defaultExtension;
+                    fn += "." + ((ExtensionFileFilter)ff).getDefaultExtension();
                 } else {
                     fn += extension;

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

-              r2024
+              r2060
                 while ((line = input.readLine()) != null) {
                     // Skip potential private information
+                    if (line.trim().toLowerCase().startsWith("osm-server.username"))
+                    if (line.trim().toLowerCase().startsWith("osm-server.username")) {
                         continue;
+                    if (line.trim().toLowerCase().startsWith("osm-server.password"))
+                    }
+                    if (line.trim().toLowerCase().startsWith("osm-server.password")) {
                         continue;
+                    if (line.trim().toLowerCase().startsWith("marker.show"))
+                    }
+                    if (line.trim().toLowerCase().startsWith("marker.show")) {
                         continue;
+                    }
                     text.append(line);
 …
         sp.setPreferredSize(new Dimension(600, 500));
+        int result = new ExtendedDialog(Main.parent, tr(tr("Status Report")), sp,
+                new String[] {tr("Copy to clipboard and close"), tr("Close") },
+                new String[] {"copy.png", "cancel.png" }).getValue();
+        ExtendedDialog ed = new ExtendedDialog(Main.parent,
+                tr("Status Report"),
+                new String[] {tr("Copy to clipboard and close"), tr("Close") });
+        ed.setButtonIcons(new String[] {"copy.png", "cancel.png" });
+        ed.setContent(sp);
+        ed.showDialog();
         if(result != 1) return;
+        if(ed.getValue() != 1) return;
         try {
             Toolkit.getDefaultToolkit().getSystemClipboard().setContents(
 …
                         public void lostOwnership(Clipboard clipboard, Transferable contents) {}
+                    }
              );
+            );
+        }
         catch (RuntimeException x) {}

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

-              r2024
+              r2060
             for (Node n : selectedNodes) {
                 for (Way w : getCurrentDataSet().ways) {
                     if (w.deleted || w.incomplete) {
+                    if (w.isDeleted() || w.incomplete) {
                         continue;
+                    }
 …
         for (Relation r : getCurrentDataSet().relations) {
             if (r.deleted || r.incomplete) {
+            if (r.isDeleted() || r.incomplete) {
                 continue;
+            }

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

-              r2024
+              r2060
             int count = 0;
             for (Way w : getCurrentDataSet().ways) {
                 if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
+                if (w.isDeleted() || w.incomplete || w.getNodesCount() < 1) {
                     continue;
+                }
 …
                 int count = 0;
                 for (Way w : getCurrentDataSet().ways) {
                     if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
+                    if (w.isDeleted() || w.incomplete || w.getNodesCount() < 1) {
                         continue;
+                    }
 …
         HashSet<String> rolesToReAdd = null;
         for (Relation r : getCurrentDataSet().relations) {
             if (r.deleted || r.incomplete) {
+            if (r.isDeleted() || r.incomplete) {
                 continue;
+            }
 …
             // modify all ways containing the nodes
             for (Way w : getCurrentDataSet().ways) {
                 if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
+                if (w.isDeleted() || w.incomplete || w.getNodesCount() < 1) {
                     continue;
+                }

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

r2024	r2060
79	79	// bounds defined? => use the bbox downloader
80	80	//
81		new DownloadOsmTaskList().download(false, areas, new PleaseWaitProgressMonitor());
	81	new DownloadOsmTaskList().download(false, areas, new PleaseWaitProgressMonitor(tr("Updating data")));
82	82	}
83	83	}

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

-              r2024
+              r2060
         protected void initMultiFetchReaderWithNodes(MultiFetchServerObjectReader reader) {
             for (OsmPrimitive primitive : toUpdate) {
                 if (primitive instanceof Node && primitive.id > 0) {
+                if (primitive instanceof Node && primitive.getId() > 0) {
                     reader.append((Node)primitive);
                 } else if (primitive instanceof Way) {
                     Way way = (Way)primitive;
                     for (Node node: way.getNodes()) {
                         if (node.id > 0) {
+                        if (node.getId() > 0) {
                             reader.append(node);
+                        }
 …
         protected void initMultiFetchReaderWithWays(MultiFetchServerObjectReader reader) {
             for (OsmPrimitive primitive : toUpdate) {
                 if (primitive instanceof Way && primitive.id > 0) {
+                if (primitive instanceof Way && primitive.getId() > 0) {
                     reader.append((Way)primitive);
+                }
 …
         protected void initMultiFetchReaderWithRelations(MultiFetchServerObjectReader reader) {
             for (OsmPrimitive primitive : toUpdate) {
                 if (primitive instanceof Relation && primitive.id > 0) {
+                if (primitive instanceof Relation && primitive.getId() > 0) {
                     reader.append((Relation)primitive);
+                }

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

-              r2024
+              r2060
 import static org.openstreetmap.josm.tools.I18n.tr;
+import java.awt.FlowLayout;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
 import java.awt.GridBagConstraints;
 import java.awt.GridBagLayout;
 import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.io.IOException;
 import java.net.HttpURLConnection;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import javax.swing.BoxLayout;
+import javax.swing.ButtonGroup;
 import javax.swing.JCheckBox;
 import javax.swing.JLabel;
 …
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
+import javax.swing.JRadioButton;
 import javax.swing.JScrollPane;
+import javax.swing.JTabbedPane;
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.APIDataSet;
 import org.openstreetmap.josm.data.conflict.ConflictCollection;
+import org.openstreetmap.josm.data.osm.Changeset;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 …
 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.gui.historycombobox.SuggestingJHistoryComboBox;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.gui.tagging.TagEditorPanel;
+import org.openstreetmap.josm.io.ChangesetProcessingType;
 import org.openstreetmap.josm.io.OsmApi;
 import org.openstreetmap.josm.io.OsmApiException;
 import org.openstreetmap.josm.io.OsmApiInitializationException;
+import org.openstreetmap.josm.io.OsmChangesetCloseException;
 import org.openstreetmap.josm.io.OsmServerWriter;
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.Shortcut;
+import org.openstreetmap.josm.tools.WindowGeometry;
 import org.xml.sax.SAXException;
 …
+    }
+    public boolean checkPreUploadConditions(OsmDataLayer layer) {
+        return checkPreUploadConditions(layer, new APIDataSet(layer.data));
+    }
+    public boolean checkPreUploadConditions(OsmDataLayer layer, APIDataSet apiData) {
+        ConflictCollection conflicts = layer.getConflicts();
+        if (conflicts !=null && !conflicts.isEmpty()) {
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("<html>There are unresolved conflicts in layer ''{0}''.<br>"
+                            + "You have to resolve them first.<html>", layer.getName()),
+                            tr("Warning"),
+                            JOptionPane.WARNING_MESSAGE
+            );
+            return false;
+        }
+        // Call all upload hooks in sequence. The upload confirmation dialog
+        // is one of these.
+        for(UploadHook hook : uploadHooks)
+            if(!hook.checkUpload(apiData.getPrimitivesToAdd(), apiData.getPrimitivesToUpdate(), apiData.getPrimitivesToDelete()))
+                return false;
+        return true;
+    }
     public void actionPerformed(ActionEvent e) {
         if (!isEnabled())
 …
+        }
+        ConflictCollection conflicts = Main.map.mapView.getEditLayer().getConflicts();
+        if (conflicts !=null && !conflicts.isEmpty()) {
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("There are unresolved conflicts. You have to resolve these first."),
+                    tr("Warning"),
+                    JOptionPane.WARNING_MESSAGE
+            );
+            Main.map.conflictDialog.showDialog();
+            return;
+        }
+        final LinkedList<OsmPrimitive> add = new LinkedList<OsmPrimitive>();
+        final LinkedList<OsmPrimitive> update = new LinkedList<OsmPrimitive>();
+        final LinkedList<OsmPrimitive> delete = new LinkedList<OsmPrimitive>();
+        for (OsmPrimitive osm : getCurrentDataSet().allPrimitives()) {
+            if (osm.get("josm/ignore") != null) {
+                continue;
+            }
+            if (osm.id == 0 && !osm.deleted) {
+                add.addLast(osm);
+            } else if (osm.modified && !osm.deleted) {
+                update.addLast(osm);
+            } else if (osm.deleted && osm.id != 0) {
+                delete.addFirst(osm);
+            }
+        }
+        if (add.isEmpty() && update.isEmpty() && delete.isEmpty()) {
+        APIDataSet apiData = new APIDataSet(Main.main.getCurrentDataSet());
+        if (apiData.isEmpty()) {
             JOptionPane.showMessageDialog(
                     Main.parent,
                     tr("No changes to upload."),
                     tr("Warning"),
                     JOptionPane.WARNING_MESSAGE
+                    JOptionPane.INFORMATION_MESSAGE
             );
             return;
+        }
+        // Call all upload hooks in sequence. The upload confirmation dialog
+        // is one of these.
+        for(UploadHook hook : uploadHooks)
+            if(!hook.checkUpload(add, update, delete))
+                return;
+        final Collection<OsmPrimitive> all = new LinkedList<OsmPrimitive>();
+        all.addAll(add);
+        all.addAll(update);
+        all.addAll(delete);
+        Main.worker.execute(new UploadDiffTask(all));
+        if (!checkPreUploadConditions(Main.map.mapView.getEditLayer(), apiData))
+            return;
+        Main.worker.execute(
+                createUploadTask(
+                        Main.map.mapView.getEditLayer(),
+                        apiData.getPrimitives(),
+                        UploadConfirmationHook.getUploadDialogPanel().getChangeset(),
+                        UploadConfirmationHook.getUploadDialogPanel().getChangesetProcessingType()
+                )
+        );
+    }
 …
         );
         switch(ret) {
+        case JOptionPane.CLOSED_OPTION: return;
+        case JOptionPane.CANCEL_OPTION: return;
+        case 0: synchronizePrimitive(id); break;
+        case 1: synchronizeDataSet(); break;
+        default:
+            // should not happen
+            throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
+            case JOptionPane.CLOSED_OPTION: return;
+            case JOptionPane.CANCEL_OPTION: return;
+            case 0: synchronizePrimitive(id); break;
+            case 1: synchronizeDataSet(); break;
+            default:
+                // should not happen
+                throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
+        }
+    }
 …
         );
         switch(ret) {
+        case JOptionPane.CLOSED_OPTION: return;
+        case 1: return;
+        case 0: synchronizeDataSet(); break;
+        default:
+            // should not happen
+            throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
+            case JOptionPane.CLOSED_OPTION: return;
+            case 1: return;
+            case 0: synchronizeDataSet(); break;
+            default:
+                // should not happen
+                throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
+        }
+    }
 …
+        }
+        if (e instanceof OsmChangesetCloseException) {
+            ExceptionDialogUtil.explainOsmChangesetCloseException((OsmChangesetCloseException)e);
+            return;
+        }
         if (e instanceof OsmApiException) {
             OsmApiException ex = (OsmApiException)e;
 …
+    class UploadConfirmationHook implements UploadHook {
+        private JCheckBox cbUseAtomicUpload;
+        protected JPanel buildChangesetControlPanel() {
+            JPanel pnl = new JPanel();
+            pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
+            pnl.add(cbUseAtomicUpload = new JCheckBox(tr("upload all changes in one request")));
+            cbUseAtomicUpload.setToolTipText(tr("Enable to upload all changes in one request, disable to use one request per changed primitive"));
+            boolean useAtomicUpload = Main.pref.getBoolean("osm-server.atomic-upload", true);
+            cbUseAtomicUpload.setSelected(useAtomicUpload);
+            cbUseAtomicUpload.setEnabled(OsmApi.getOsmApi().hasChangesetSupport());
+            return pnl;
+    static public class UploadConfirmationHook implements UploadHook {
+        static private UploadDialogPanel uploadDialogPanel;
+        static public UploadDialogPanel getUploadDialogPanel() {
+            if (uploadDialogPanel == null) {
+                uploadDialogPanel = new UploadDialogPanel();
+            }
+            return uploadDialogPanel;
+        }
         public boolean checkUpload(Collection<OsmPrimitive> add, Collection<OsmPrimitive> update, Collection<OsmPrimitive> delete) {
+            JPanel p = new JPanel(new GridBagLayout());
+            OsmPrimitivRenderer renderer = new OsmPrimitivRenderer();
+            if (!add.isEmpty()) {
+                p.add(new JLabel(tr("Objects to add:")), GBC.eol());
+                JList l = new JList(add.toArray());
+                l.setCellRenderer(renderer);
+                l.setVisibleRowCount(l.getModel().getSize() < 6 ? l.getModel().getSize() : 10);
+                p.add(new JScrollPane(l), GBC.eol().fill());
+            }
+            if (!update.isEmpty()) {
+                p.add(new JLabel(tr("Objects to modify:")), GBC.eol());
+                JList l = new JList(update.toArray());
+                l.setCellRenderer(renderer);
+                l.setVisibleRowCount(l.getModel().getSize() < 6 ? l.getModel().getSize() : 10);
+                p.add(new JScrollPane(l), GBC.eol().fill());
+            }
+            if (!delete.isEmpty()) {
+                p.add(new JLabel(tr("Objects to delete:")), GBC.eol());
+                JList l = new JList(delete.toArray());
+                l.setCellRenderer(renderer);
+                l.setVisibleRowCount(l.getModel().getSize() < 6 ? l.getModel().getSize() : 10);
+                p.add(new JScrollPane(l), GBC.eol().fill());
+            }
+            p.add(new JLabel(tr("Provide a brief comment for the changes you are uploading:")), GBC.eol().insets(0, 5, 10, 3));
+            SuggestingJHistoryComboBox cmt = new SuggestingJHistoryComboBox();
+            List<String> cmtHistory = new LinkedList<String>(Main.pref.getCollection(HISTORY_KEY, new LinkedList<String>()));
+            cmt.setHistory(cmtHistory);
+            p.add(cmt, GBC.eol().fill(GBC.HORIZONTAL));
+            //final JTextField cmt = new JTextField(lastCommitComment);
+            // configuration options for atomic upload
+            p.add(buildChangesetControlPanel(), GBC.eol().fill(GridBagConstraints.HORIZONTAL));
+            final UploadDialogPanel panel = getUploadDialogPanel();
+            panel.setUploadedPrimitives(add, update, delete);
+            ExtendedDialog dialog = new ExtendedDialog(
+                    Main.parent,
+                    tr("Upload these changes?"),
+                    new String[] {tr("Upload Changes"), tr("Cancel")}
+            ) {
+                @Override
+                public void setVisible(boolean visible) {
+                    if (visible) {
+                        new WindowGeometry(
+                                panel.getClass().getName(),
+                                WindowGeometry.centerInWindow(JOptionPane.getFrameForComponent(Main.parent), new Dimension(400,400))
+                        ).apply(this);
+                        panel.startUserInput();
+                    } else {
+                        new WindowGeometry(this).remember(panel.getClass().getName());
+                    }
+                    super.setVisible(visible);
+                }
+            };
+            dialog.setButtonIcons(new String[] {"upload.png", "cancel.png"});
+            dialog.setContent(panel, false /* no scroll pane */);
             while(true) {
+                int result = new ExtendedDialog(Main.parent,
+                        tr("Upload these changes?"),
+                        p,
+                        new String[] {tr("Upload Changes"), tr("Cancel")},
+                        new String[] {"upload.png", "cancel.png"}).getValue();
+                dialog.showDialog();
+                int result = dialog.getValue();
                 // cancel pressed
                 if (result != 1) return false;
                 // don't allow empty commit message
                 if (cmt.getText().trim().length() < 3) {
+                if (! panel.hasChangesetComment()) {
                     continue;
+                }
+                // store the history of comments
+                cmt.addCurrentItemToHistory();
+                Main.pref.putCollection(HISTORY_KEY, cmt.getHistory());
+                Main.pref.put("osm-server.atomic-upload", cbUseAtomicUpload.isSelected());
+                panel.rememberUserInput();
                 break;
+            }
 …
+    }
+    class UploadDiffTask extends  PleaseWaitRunnable {
+    public UploadDiffTask createUploadTask(OsmDataLayer layer, Collection<OsmPrimitive> toUpload, Changeset changeset, ChangesetProcessingType changesetProcessingType) {
+        return new UploadDiffTask(layer, toUpload, changeset, changesetProcessingType);
+    }
+    public class UploadDiffTask extends  PleaseWaitRunnable {
         private boolean uploadCancelled = false;
         private Exception lastException = null;
         private Collection <OsmPrimitive> toUpload;
         private OsmServerWriter writer;
+        public UploadDiffTask(Collection <OsmPrimitive> toUpload) {
+            super(tr("Uploading"),false /* don't ignore exceptions */);
+        private OsmDataLayer layer;
+        private Changeset changeset;
+        private ChangesetProcessingType changesetProcessingType;
+        private UploadDiffTask(OsmDataLayer layer, Collection <OsmPrimitive> toUpload, Changeset changeset, ChangesetProcessingType changesetProcessingType) {
+            super(tr("Uploading data for layer ''{0}''", layer.getName()),false /* don't ignore exceptions */);
             this.toUpload = toUpload;
+            this.layer = layer;
+            this.changeset = changeset;
+            this.changesetProcessingType = changesetProcessingType == null ? ChangesetProcessingType.USE_NEW_AND_CLOSE : changesetProcessingType;
+        }
 …
             writer = new OsmServerWriter();
             try {
+                writer.uploadOsm(getCurrentDataSet().version, toUpload, progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
+                ProgressMonitor monitor = progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false);
+                writer.uploadOsm(layer.data.version, toUpload, changeset,changesetProcessingType, monitor);
             } catch (Exception sxe) {
                 if (uploadCancelled) {
 …
             // partially uploaded
             //
             getEditLayer().cleanupAfterUpload(writer.getProcessedPrimitives());
             DataSet.fireSelectionChanged(getEditLayer().data.getSelected());
             getEditLayer().fireDataChange();
+            layer.cleanupAfterUpload(writer.getProcessedPrimitives());
+            DataSet.fireSelectionChanged(layer.data.getSelected());
+            layer.fireDataChange();
             if (lastException != null) {
                 handleFailedUpload(lastException);
+            } else {
+                layer.onPostUploadToServer();
+            }
+        }
 …
             uploadCancelled = true;
             if (writer != null) {
+                writer.disconnectActiveConnection();
+                writer.cancel();
+            }
+        }
+        public boolean isSuccessful() {
+            return !isCancelled() && !isFailed();
+        }
+        public boolean isCancelled() {
+            return uploadCancelled;
+        }
+        public boolean isFailed() {
+            return lastException != null;
+        }
+    }
+    /**
+     * The panel displaying information about primitives to upload and providing
+     * UI widgets for entering the changeset comment and other configuration
+     * settings.
+     *
+     */
+    static public class UploadDialogPanel extends JPanel {
+        private JList lstAdd;
+        private JList lstUpdate;
+        private JList lstDelete;
+        private JLabel lblAdd;
+        private JLabel lblUpdate;
+        private JLabel lblDelete;
+        private JPanel pnlLists;
+        private JCheckBox cbUseAtomicUpload;
+        private SuggestingJHistoryComboBox cmt;
+        private TagEditorPanel tagEditorPanel;
+        private JTabbedPane southTabbedPane;
+        private ButtonGroup bgChangesetHandlingOptions;
+        private Map<ChangesetProcessingType, JRadioButton> rbChangesetHandlingOptions;
+        protected JPanel buildListsPanel() {
+            pnlLists = new JPanel();
+            pnlLists.setLayout(new GridBagLayout());
+            return pnlLists;
+        }
+        protected JPanel buildChangesetHandlingControlPanel() {
+            JPanel pnl = new JPanel();
+            pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
+            bgChangesetHandlingOptions = new ButtonGroup();
+            rbChangesetHandlingOptions = new HashMap<ChangesetProcessingType, JRadioButton>();
+            ChangesetProcessingTypeChangedAction a = new ChangesetProcessingTypeChangedAction();
+            for(ChangesetProcessingType type: ChangesetProcessingType.values()) {
+                rbChangesetHandlingOptions.put(type, new JRadioButton());
+                rbChangesetHandlingOptions.get(type).addActionListener(a);
+            }
+            JRadioButton rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_CLOSE);
+            rb.setText(tr("Use a new changeset and close it"));
+            rb.setToolTipText(tr("Select to upload the data using a new changeset and to close the changeset after the upload"));
+            rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_LEAVE_OPEN);
+            rb.setText(tr("Use a new changeset and leave it open"));
+            rb.setToolTipText(tr("Select to upload the data using a new changeset and to leave the changeset open after the upload"));
+            pnl.add(new JLabel(tr("Upload to a new or to an existing changeset?")));
+            pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_CLOSE));
+            pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_LEAVE_OPEN));
+            pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_CLOSE));
+            pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_LEAVE_OPEN));
+            for(ChangesetProcessingType type: ChangesetProcessingType.values()) {
+                rbChangesetHandlingOptions.get(type).setVisible(false);
+                bgChangesetHandlingOptions.add(rbChangesetHandlingOptions.get(type));
+            }
+            return pnl;
+        }
+        protected JPanel buildChangesetControlPanel() {
+            JPanel pnl = new JPanel();
+            pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
+            pnl.add(cbUseAtomicUpload = new JCheckBox(tr("upload all changes in one request")));
+            cbUseAtomicUpload.setToolTipText(tr("Enable to upload all changes in one request, disable to use one request per changed primitive"));
+            boolean useAtomicUpload = Main.pref.getBoolean("osm-server.atomic-upload", true);
+            cbUseAtomicUpload.setSelected(useAtomicUpload);
+            cbUseAtomicUpload.setEnabled(OsmApi.getOsmApi().hasSupportForDiffUploads());
+            pnl.add(buildChangesetHandlingControlPanel());
+            return pnl;
+        }
+        protected JPanel buildUploadControlPanel() {
+            JPanel pnl = new JPanel();
+            pnl.setLayout(new GridBagLayout());
+            pnl.add(new JLabel(tr("Provide a brief comment for the changes you are uploading:")), GBC.eol().insets(0, 5, 10, 3));
+            cmt = new SuggestingJHistoryComboBox();
+            List<String> cmtHistory = new LinkedList<String>(Main.pref.getCollection(HISTORY_KEY, new LinkedList<String>()));
+            cmt.setHistory(cmtHistory);
+            pnl.add(cmt, GBC.eol().fill(GBC.HORIZONTAL));
+            // configuration options for atomic upload
+            //
+            pnl.add(buildChangesetControlPanel(), GBC.eol().fill(GridBagConstraints.HORIZONTAL));
+            return pnl;
+        }
+        protected void build() {
+            setLayout(new GridBagLayout());
+            GridBagConstraints gc = new GridBagConstraints();
+            gc.fill = GridBagConstraints.BOTH;
+            gc.weightx = 1.0;
+            gc.weighty = 1.0;
+            add(buildListsPanel(), gc);
+            southTabbedPane = new JTabbedPane();
+            southTabbedPane.add(buildUploadControlPanel());
+            tagEditorPanel = new TagEditorPanel();
+            southTabbedPane.add(tagEditorPanel);
+            southTabbedPane.setTitleAt(0, tr("Settings"));
+            southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
+            JPanel pnl = new JPanel();
+            pnl.setLayout(new BorderLayout());
+            pnl.add(southTabbedPane,BorderLayout.CENTER);
+            gc.fill = GridBagConstraints.HORIZONTAL;
+            gc.gridy = 1;
+            gc.weightx = 1.0;
+            gc.weighty = 0.0;
+            add(pnl, gc);
+        }
+        protected UploadDialogPanel() {
+            OsmPrimitivRenderer renderer = new OsmPrimitivRenderer();
+            lstAdd = new JList();
+            lstAdd.setCellRenderer(renderer);
+            lstAdd.setVisibleRowCount(Math.min(lstAdd.getModel().getSize(), 10));
+            lstUpdate = new JList();
+            lstUpdate.setCellRenderer(renderer);
+            lstUpdate.setVisibleRowCount(Math.min(lstUpdate.getModel().getSize(), 10));
+            lstDelete = new JList();
+            lstDelete.setCellRenderer(renderer);
+            lstDelete.setVisibleRowCount(Math.min(lstDelete.getModel().getSize(), 10));
+            build();
+        }
+        public void setUploadedPrimitives(Collection<OsmPrimitive> add, Collection<OsmPrimitive> update, Collection<OsmPrimitive> delete) {
+            lstAdd.setListData(add.toArray());
+            lstUpdate.setListData(update.toArray());
+            lstDelete.setListData(delete.toArray());
+            GridBagConstraints gcLabel = new GridBagConstraints();
+            gcLabel.fill = GridBagConstraints.HORIZONTAL;
+            gcLabel.weightx = 1.0;
+            gcLabel.weighty = 0.0;
+            gcLabel.anchor = GridBagConstraints.FIRST_LINE_START;
+            GridBagConstraints gcList = new GridBagConstraints();
+            gcList.fill = GridBagConstraints.BOTH;
+            gcList.weightx = 1.0;
+            gcList.weighty = 1.0;
+            gcList.anchor = GridBagConstraints.CENTER;
+            pnlLists.removeAll();
+            int y = -1;
+            if (!add.isEmpty()) {
+                y++;
+                gcLabel.gridy = y;
+                pnlLists.add(lblAdd = new JLabel(tr("Objects to add:")), gcLabel);
+                y++;
+                gcList.gridy = y;
+                pnlLists.add(new JScrollPane(lstAdd), gcList);
+            }
+            if (!update.isEmpty()) {
+                y++;
+                gcLabel.gridy = y;
+                pnlLists.add(lblUpdate = new JLabel(tr("Objects to modify:")), gcLabel);
+                y++;
+                gcList.gridy = y;
+                pnlLists.add(new JScrollPane(lstUpdate), gcList);
+            }
+            if (!delete.isEmpty()) {
+                y++;
+                gcLabel.gridy = y;
+                pnlLists.add(lblDelete = new JLabel(tr("Objects to delete:")), gcLabel);
+                y++;
+                gcList.gridy = y;
+                pnlLists.add(new JScrollPane(lstDelete), gcList);
+            }
+        }
+        public boolean hasChangesetComment() {
+            if (!getChangesetProcessingType().isUseNew())
+                return true;
+            return cmt.getText().trim().length() >= 3;
+        }
+        public void rememberUserInput() {
+            // store the history of comments
+            cmt.addCurrentItemToHistory();
+            Main.pref.putCollection(HISTORY_KEY, cmt.getHistory());
+            Main.pref.put("osm-server.atomic-upload", cbUseAtomicUpload.isSelected());
+        }
+        public void startUserInput() {
+            tagEditorPanel.initAutoCompletion(Main.main.getEditLayer());
+            initChangesetProcessingType();
+            cmt.getEditor().selectAll();
+            cmt.requestFocus();
+        }
+        public ChangesetProcessingType getChangesetProcessingType() {
+            ChangesetProcessingType changesetProcessingType = null;
+            for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
+                if (rbChangesetHandlingOptions.get(type).isSelected()) {
+                    changesetProcessingType = type;
+                    break;
+                }
+            }
+            return changesetProcessingType == null ?
+                    ChangesetProcessingType.USE_NEW_AND_CLOSE :
+                        changesetProcessingType;
+        }
+        public Changeset getChangeset() {
+            Changeset changeset = new Changeset();
+            tagEditorPanel.getModel().applyToPrimitive(changeset);
+            changeset.put("comment", cmt.getText());
+            return changeset;
+        }
+        protected void initChangesetProcessingType() {
+            for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
+                // show options for new changeset, disable others
+                //
+                rbChangesetHandlingOptions.get(type).setVisible(type.isUseNew());
+            }
+            if (OsmApi.getOsmApi().getCurrentChangeset() != null) {
+                Changeset cs = OsmApi.getOsmApi().getCurrentChangeset();
+                for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
+                    // show options for using existing changeset
+                    //
+                    if (!type.isUseNew()) {
+                        rbChangesetHandlingOptions.get(type).setVisible(true);
+                    }
+                }
+                JRadioButton rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_CLOSE);
+                rb.setText(tr("Use the existing changeset {0} and close it after upload",cs.getId()));
+                rb.setToolTipText(tr("Select to upload to the existing changeset {0} and to close the changeset after this upload",cs.getId()));
+                rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_LEAVE_OPEN);
+                rb.setText(tr("Use the existing changeset {0} and leave it open",cs.getId()));
+                rb.setToolTipText(tr("Select to upload to the existing changeset {0} and to leave the changeset open for further uploads",cs.getId()));
+                rbChangesetHandlingOptions.get(getChangesetProcessingType()).setSelected(true);
+            } else {
+                ChangesetProcessingType type = getChangesetProcessingType();
+                if (!type.isUseNew()) {
+                    type = ChangesetProcessingType.USE_NEW_AND_CLOSE;
+                }
+                rbChangesetHandlingOptions.get(type).setSelected(true);
+            }
+        }
+        class ChangesetProcessingTypeChangedAction implements ActionListener {
+            public void actionPerformed(ActionEvent e) {
+                ChangesetProcessingType type = getChangesetProcessingType();
+                if (type.isUseNew()) {
+                    tagEditorPanel.setEnabled(true);
+                    southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
+                    cmt.setEnabled(true);
+                } else {
+                    tagEditorPanel.setEnabled(false);
+                    cmt.setEnabled(false);
+                    Changeset cs = OsmApi.getOsmApi().getCurrentChangeset();
+                    if (cs != null) {
+                        tagEditorPanel.getModel().initFromPrimitive(cs);
+                        southTabbedPane.setTitleAt(1, tr("Tags of changeset {0} (read-only)", cs.getId()));
+                        cmt.setText(cs.get("comment" == null ? "" : cs.get("comment")));
+                    }
+                }
+            }
+        }

/trunk/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

-              r2024
+              r2060
 import static org.openstreetmap.josm.tools.I18n.tr;
+import java.awt.AWTEvent;
+import java.awt.Cursor;
+import java.awt.EventQueue;
+import java.awt.Toolkit;
+import java.awt.event.AWTEventListener;
 import java.awt.event.ActionEvent;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.command.DeleteCommand;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
 import org.openstreetmap.josm.gui.MapFrame;
 …
  * @author imi
  */
+public class DeleteAction extends MapMode {
+/**
+ * This class contains stubs for highlighting affected primitives when affected.
+ * However, way segments can be deleted as well, but cannot be highlighted
+ * alone. If the highlight feature for this delete action is to be implemented
+ * properly, highlighting way segments must be possible first. --xeen, 2009-09-02
+ */
+public class DeleteAction extends MapMode implements AWTEventListener {
+    //private boolean drawTargetHighlight;
+    private boolean drawTargetCursor;
+    //private Collection<? extends OsmPrimitive> oldPrims = null;
+    // Cache previous mouse event (needed when only the modifier keys are
+    // pressed but the mouse isn't moved)
+    private MouseEvent oldEvent = null;
+    private enum Cursors {
+        none,
+        node,
+        segment,
+        way_node_only,
+        way_normal,
+        way_only;
+        private Cursor c = null;
+        // This loads and caches the cursor for each
+        public Cursor cursor() {
+            if(c == null) {
+                String nm = "delete_" + this.name().toLowerCase();
+                // "None" has no special icon
+                nm = nm.equals("delete_none") ? "delete" : nm;
+                this.c = ImageProvider.getCursor("normal", nm);
+            }
+            return c;
+        }
+    }
+    private Cursors currCursor = Cursors.none;
     /**
 …
         if (!isEnabled())
             return;
+        //drawTargetHighlight = Main.pref.getBoolean("draw.target-highlight", true);
+        drawTargetCursor = Main.pref.getBoolean("draw.target-cursor", true);
         Main.map.mapView.addMouseListener(this);
+        Main.map.mapView.addMouseMotionListener(this);
+        // This is required to update the cursors when ctrl/shift/alt is pressed
+        try {
+            Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.KEY_EVENT_MASK);
+        } catch (SecurityException ex) {}
+        currCursor = Cursors.none;
+    }
 …
         super.exitMode();
         Main.map.mapView.removeMouseListener(this);
+        Main.map.mapView.removeMouseMotionListener(this);
+        try {
+            Toolkit.getDefaultToolkit().removeAWTEventListener(this);
+        } catch (SecurityException ex) {}
+    }
 …
     /**
+     * Listen to mouse move to be able to update the cursor (and highlights)
+     * @param MouseEvent The mouse event that has been captured
+     */
+    @Override public void mouseMoved(MouseEvent e) {
+        oldEvent = e;
+        updateCursor(e, e.getModifiers());
+    }
+    /**
+     * This function handles all work related to updating the cursor and
+     * highlights. For now, only the cursor is enabled because highlighting
+     * requires WaySegment to be highlightable.
+     *
+     * Normally the mouse event also contains the modifiers. However, when the
+     * mouse is not moved and only modifier keys are pressed, no mouse event
+     * occurs. We can use AWTEvent to catch those but still lack a proper
+     * mouseevent. Instead we copy the previous event and only update the
+     * modifiers.
+     *
+     * @param MouseEvent
+     * @parm int modifiers
+     */
+    private void updateCursor(MouseEvent e, int modifiers) {
+        if(!Main.map.mapView.isActiveLayerVisible() || e == null)
+            return;
+        // Clean old highlights
+        //cleanOldHighlights();
+        Command c = buildDeleteCommands(e, modifiers, true);
+        if(c == null) {
+            setCursor(Cursors.none);
+            return;
+        }
+        Collection<OsmPrimitive> prims = new HashSet<OsmPrimitive>();
+        Collection<OsmPrimitive> mods = new HashSet<OsmPrimitive>();
+        c.fillModifiedData(mods, prims, prims);
+        if(prims.size() == 0 && mods.size() == 0) {
+            // Default-Cursor
+            setCursor(Cursors.none);
+            return;
+        }
+        // There are no deleted parts if solely a way segment is deleted
+        // This is no the case when actually deleting only a segment but that
+        // segment happens to be the whole way. This is an acceptable error
+        // though
+        if(prims.size() == 0) {
+            setCursor(Cursors.segment);
+        } else if(prims.size() == 1 && prims.toArray()[0] instanceof Node) {
+            setCursor(Cursors.node);
+        } else if(prims.size() == 1 && prims.toArray()[0] instanceof Way) {
+            setCursor(Cursors.way_only);
+        } else {
+            // Decide between non-accel click where "useless" nodes are deleted
+            // and ctrl-click where nodes and ways are deleted
+            boolean ctrl = (modifiers & ActionEvent.CTRL_MASK) != 0;
+            if(ctrl) {
+                setCursor(Cursors.way_node_only);
+            } else {
+                setCursor(Cursors.way_normal);
+            }
+        }
+        // Needs to implement WaySegment highlight first
+        /*if(drawTargetHighlight) {
+            // Add new highlights
+            for(OsmPrimitive p : prims) {
+                p.highlighted = true;
+            }
+            oldPrims = prims;
+        }*/
+        // We only need to repaint if the highlights changed
+        //Main.map.mapView.repaint();
+    }
+    /**
+     * Small helper function that cleans old highlights
+     */
+    /*private void cleanOldHighlights() {
+        if(oldPrims == null)
+            return;
+        for(OsmPrimitive p: oldPrims) {
+            p.highlighted = false;
+        }
+    }*/
+    /**
      * If user clicked with the left button, delete the nearest object.
      * position.
 …
         Main.map.mapView.requestFocus();
+        boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0;
+        boolean shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0;
+        boolean alt = (e.getModifiers() & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
+        Command c = buildDeleteCommands(e, e.getModifiers(), false);
+        if (c != null) {
+            Main.main.undoRedo.add(c);
+        }
+        getCurrentDataSet().setSelected();
+        Main.map.mapView.repaint();
+    }
+    @Override public String getModeHelpText() {
+        return tr("Click to delete. Shift: delete way segment. Alt: don't delete unused nodes when deleting a way. Ctrl: delete referring objects.");
+    }
+    @Override public boolean layerIsSupported(Layer l) {
+        return l instanceof OsmDataLayer;
+    }
+    @Override
+    protected void updateEnabledState() {
+        setEnabled(Main.map != null && Main.map.mapView != null && Main.map.mapView.isActiveLayerDrawable());
+    }
+    /**
+     * Deletes the relation in the context of the given layer. Also notifies
+     * {@see RelationDialogManager} and {@see OsmDataLayer#fireDataChange()} events.
+     *
+     * @param layer the layer in whose context the relation is deleted. Must not be null.
+     * @param toDelete  the relation to be deleted. Must  not be null.
+     * @exception IllegalArgumentException thrown if layer is null
+     * @exception IllegalArgumentException thrown if toDelete is nul
+     */
+    public static void deleteRelation(OsmDataLayer layer, Relation toDelete) {
+        if (layer == null)
+            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
+        if (toDelete == null)
+            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "toDelete"));
+        Command cmd = DeleteCommand.delete(layer, Collections.singleton(toDelete));
+        if (cmd != null) {
+            // cmd can be null if the user cancels dialogs DialogCommand displays
+            Main.main.undoRedo.add(cmd);
+            RelationDialogManager.getRelationDialogManager().close(layer, toDelete);
+            layer.fireDataChange();
+        }
+    }
+    /**
+     * This function takes any mouse event argument and builds the list of elements
+     * that should be deleted but does not actually delete them.
+     * @param e MouseEvent from which modifiers and position are taken
+     * @param int modifiers For explanation: @see updateCursor
+     * @param Simulate Set to true if the user should be bugged with additional
+     *        dialogs
+     * @return
+     */
+    private Command buildDeleteCommands(MouseEvent e, int modifiers, boolean simulate) {
+        // Note: CTRL is the only modifier that is checked in MouseMove, don't
+        // forget updating it there
+        boolean ctrl = (modifiers & ActionEvent.CTRL_MASK) != 0;
+        boolean shift = (modifiers & ActionEvent.SHIFT_MASK) != 0;
+        boolean alt = (modifiers & (ActionEvent.ALT_MASK|InputEvent.ALT_GRAPH_MASK)) != 0;
         OsmPrimitive sel = Main.map.mapView.getNearestNode(e.getPoint());
 …
                     c = DeleteCommand.deleteWaySegment(getEditLayer(),ws);
                 } else if (ctrl) {
+                    c = DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton((OsmPrimitive)ws.way));
+                    c = DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton((OsmPrimitive)ws.way),true);
                 } else {
+                    c = DeleteCommand.delete(getEditLayer(),Collections.singleton((OsmPrimitive)ws.way), !alt);
+                    c = DeleteCommand.delete(getEditLayer(),Collections.singleton((OsmPrimitive)ws.way), !alt, simulate);
+                }
+            }
 …
             c = DeleteCommand.deleteWithReferences(getEditLayer(),Collections.singleton(sel));
         } else {
+            c = DeleteCommand.delete(getEditLayer(),Collections.singleton(sel), !alt);
+        }
+        if (c != null) {
+            Main.main.undoRedo.add(c);
+        }
+        getCurrentDataSet().setSelected();
+        Main.map.mapView.repaint();
+    }
+    @Override public String getModeHelpText() {
+        return tr("Click to delete. Shift: delete way segment. Alt: don't delete unused nodes when deleting a way. Ctrl: delete referring objects.");
+    }
+    @Override public boolean layerIsSupported(Layer l) {
+        return l instanceof OsmDataLayer;
+    }
+    @Override
+    protected void updateEnabledState() {
+        setEnabled(Main.map != null && Main.map.mapView != null && Main.map.mapView.isActiveLayerDrawable());
+    }
+    /**
+     * Deletes the relation in the context of the given layer. Also notifies
+     * {@see RelationDialogManager} and {@see OsmDataLayer#fireDataChange()} events.
+     *
+     * @param layer the layer in whose context the relation is deleted. Must not be null.
+     * @param toDelete  the relation to be deleted. Must  not be null.
+     * @exception IllegalArgumentException thrown if layer is null
+     * @exception IllegalArgumentException thrown if toDelete is nul
+     */
+    public static void deleteRelation(OsmDataLayer layer, Relation toDelete) {
+        if (layer == null)
+            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
+        if (toDelete == null)
+            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "toDelete"));
+        if (toDelete == null)
+            return;
+        Command cmd = DeleteCommand.delete(layer, Collections.singleton(toDelete));
+        if (cmd != null) {
+            // cmd can be null if the user cancels dialogs DialogCommand displays
+            //
+            Main.main.undoRedo.add(cmd);
+            RelationDialogManager.getRelationDialogManager().close(layer, toDelete);
+            layer.fireDataChange();
+        }
+            c = DeleteCommand.delete(getEditLayer(),Collections.singleton(sel), !alt, simulate);
+        }
+        return c;
+    }
+    /**
+     * This function sets the given cursor in a safe way. This implementation
+     * differs from the on in DrawAction (it is favorable, too).
+     * FIXME: Update DrawAction to use this "setCursor-style" and move function
+     * to MapMode.
+     * @param c
+     */
+    private void setCursor(final Cursors c) {
+        if(currCursor.equals(c) || (!drawTargetCursor && currCursor.equals(Cursors.none)))
+            return;
+        try {
+            // We invoke this to prevent strange things from happening
+            EventQueue.invokeLater(new Runnable() {
+                public void run() {
+                    // Don't change cursor when mode has changed already
+                    if(!(Main.map.mapMode instanceof DeleteAction))
+                        return;
+                    Main.map.mapView.setCursor(c.cursor());
+                    //System.out.println("Set cursor to: " + c.name());
+                }
+            });
+            currCursor = c;
+        } catch(Exception e) {}
+    }
+    /**
+     * This is required to update the cursors when ctrl/shift/alt is pressed
+     */
+    public void eventDispatched(AWTEvent e) {
+        // We don't have a mouse event, so we pass the old mouse event but the
+        // new modifiers.
+        updateCursor(oldEvent, ((InputEvent)e).getModifiers());
+    }
+}

/trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

r2024	r2060
765	765	Way way = null;
766	766	for (Way w : getCurrentDataSet().ways) {
767		if (w.~~deleted~~ \|\| w.incomplete \|\| w.getNodesCount() < 1) {
	767	if (w.isDeleted() \|\| w.incomplete \|\| w.getNodesCount() < 1) {
768	768	continue;
769	769	}

/trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

-              r2024
+              r2060
                     if(s.size() > max)
+                    {
+                        if(1 != new ExtendedDialog(Main.parent, tr("Move elements"),
+                                tr("You did move more than {0} elements. "
+                                        + "Moving a large number of elements is often an error.\n"
+                                        + "Really move them?", max),
+                                        new String[] {tr("Move them"), tr("Undo move")},
+                                        new String[] {"reorder.png", "cancel.png"}).getValue())
+                        ExtendedDialog ed = new ExtendedDialog(
+                                Main.parent,
+                                tr("Move elements"),
+                                new String[] {tr("Move them"), tr("Undo move")});
+                        ed.setButtonIcons(new String[] {"reorder.png", "cancel.png"});
+                        ed.setContent(tr("You moved more than {0} elements. "
+                                + "Moving a large number of elements is often an error.\n"
+                                + "Really move them?", max));
+                        ed.toggleEnable("movedManyElements");
+                        ed.setToggleCheckboxText(tr("Always move and don't show dialog again"));
+                        ed.showDialog();
+                        if(ed.getValue() != 1 && ed.getValue() != ExtendedDialog.DialogNotShown)
+                        {
                             Main.main.undoRedo.undo();

/trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

-              r2024
+              r2060
             switch (mode) {
+            case NONE:
+                return false;
+            case MISSING_KEY:
+                return osm.get(key) == null;
+            case ANY:
+                return true;
+            case ANY_VALUE:
+                return osm.get(key) != null;
+            case ANY_KEY:
+                for (String v:osm.getKeys().values()) {
+                    if (v.equals(value))
+                        return true;
+                }
+                return false;
+            case EXACT:
+                return value.equals(osm.get(key));
+            case ANY_KEY_REGEXP:
+                for (String v:osm.getKeys().values()) {
+                    if (valuePattern.matcher(v).matches())
+                        return true;
+                }
+                return false;
+            case ANY_VALUE_REGEXP:
+            case EXACT_REGEXP:
+                for (Entry<String, String> entry:osm.entrySet()) {
+                    if (keyPattern.matcher(entry.getKey()).matches()) {
+                        if (mode == Mode.ANY_VALUE_REGEXP
+                                || valuePattern.matcher(entry.getValue()).matches())
+                case NONE:
+                    return false;
+                case MISSING_KEY:
+                    return osm.get(key) == null;
+                case ANY:
+                    return true;
+                case ANY_VALUE:
+                    return osm.get(key) != null;
+                case ANY_KEY:
+                    for (String v:osm.getKeys().values()) {
+                        if (v.equals(value))
                             return true;
+                    }
+                }
+                return false;
+            case MISSING_KEY_REGEXP:
+                for (String k:osm.keySet()) {
+                    if (keyPattern.matcher(k).matches())
+                        return false;
+                }
+                return true;
+                    return false;
+                case EXACT:
+                    return value.equals(osm.get(key));
+                case ANY_KEY_REGEXP:
+                    for (String v:osm.getKeys().values()) {
+                        if (valuePattern.matcher(v).matches())
+                            return true;
+                    }
+                    return false;
+                case ANY_VALUE_REGEXP:
+                case EXACT_REGEXP:
+                    for (Entry<String, String> entry:osm.entrySet()) {
+                        if (keyPattern.matcher(entry.getKey()).matches()) {
+                            if (mode == Mode.ANY_VALUE_REGEXP
+                                    || valuePattern.matcher(entry.getValue()).matches())
+                                return true;
+                        }
+                    }
+                    return false;
+                case MISSING_KEY_REGEXP:
+                    for (String k:osm.keySet()) {
+                        if (keyPattern.matcher(k).matches())
+                            return false;
+                    }
+                    return true;
+            }
             throw new AssertionError("Missed state");
 …
     private static class Modified extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return osm.modified || osm.id == 0;
+            return osm.isModified() || osm.getId() == 0;
+        }
         @Override public String toString() {return "modified";}

/trunk/src/org/openstreetmap/josm/actions/search/SelectionWebsiteLoader.java

r2024	r2060
48	48	Map<Long, String> ids = idReader.parseIds(in);
49	49	for (OsmPrimitive osm : Main.main.getCurrentDataSet().allNonDeletedPrimitives()) {
50		if (ids.containsKey(osm.id) && osm.getClass().getName().toLowerCase().endsWith(ids.get(osm.id))) {
	50	if (ids.containsKey(osm.getId()) && osm.getClass().getName().toLowerCase().endsWith(ids.get(osm.getId()))) {
51	51	if (mode == SearchAction.SearchMode.remove) {
52	52	sel.remove(osm);

/trunk/src/org/openstreetmap/josm/command/ChangeCommand.java

-              r2024
+              r2060
         super.executeCommand();
         osm.cloneFrom(newOsm);
         osm.modified = true;
+        osm.setModified(true);
         return true;
+    }
 …
         String msg = "";
         switch(OsmPrimitiveType.from(osm)) {
+        case NODE: msg = marktr("Change node {0}"); break;
+        case WAY: msg = marktr("Change way {0}"); break;
+        case RELATION: msg = marktr("Change relation {0}"); break;
+            case NODE: msg = marktr("Change node {0}"); break;
+            case WAY: msg = marktr("Change way {0}"); break;
+            case RELATION: msg = marktr("Change relation {0}"); break;
+        }
         return new DefaultMutableTreeNode(

/trunk/src/org/openstreetmap/josm/command/ChangePropertyCommand.java

-              r2024
+              r2060
         if (value == null) {
             for (OsmPrimitive osm : objects) {
                 osm.modified = true;
+                osm.setModified(true);
                 osm.remove(key);
+            }
         } else {
             for (OsmPrimitive osm : objects) {
                 osm.modified = true;
+                osm.setModified(true);
                 osm.put(key, value);
+            }

/trunk/src/org/openstreetmap/josm/command/ChangeRelationMemberRoleCommand.java

-              r2024
+              r2060
         relation.getMember(position).role = newRole;
         oldModified = relation.modified;
         relation.modified = true;
+        oldModified = relation.isModified();
+        relation.setModified(true);
         return true;
+    }
 …
     @Override public void undoCommand() {
         relation.getMember(position).role = oldRole;
         relation.modified = oldModified;
+        relation.setModified(oldModified);
+    }

/trunk/src/org/openstreetmap/josm/command/Command.java

-              r2024
+              r2060
             e.getKey().cloneFrom(e.getValue());
+        }
-        getLayer().setModified(true);
+    }
 …
         if (o != null)
             return o;
         Main.debug("unable to find osm with id: " + osm.id + " hashCode: " + osm.hashCode());
+        Main.debug("unable to find osm with id: " + osm.getId() + " hashCode: " + osm.hashCode());
         for (OsmPrimitive t : cloneMap.keySet()) {
             OsmPrimitive to = cloneMap.get(t);
             Main.debug("now: " + t.id + " hashCode: " + t.hashCode());
             Main.debug("orig: " + to.id + " hashCode: " + to.hashCode());
+            Main.debug("now: " + t.getId() + " hashCode: " + t.hashCode());
+            Main.debug("orig: " + to.getId() + " hashCode: " + to.hashCode());
+        }
         return o;

/trunk/src/org/openstreetmap/josm/command/CoordinateConflictResolveCommand.java

r2024	r2060
45	45	return new DefaultMutableTreeNode(
46	46	new JLabel(
47		tr("Resolve conflicts in coordinates in {0}",conflict.getMy().id),
	47	tr("Resolve conflicts in coordinates in {0}",conflict.getMy().getId()),
48	48	ImageProvider.get("data", "object"),
49	49	JLabel.HORIZONTAL

/trunk/src/org/openstreetmap/josm/command/DeleteCommand.java

-              r2024
+              r2060
  */
 public class DeleteCommand extends Command {
     /**
      * The primitives that get deleted.
 …
      * If a way is deleted, only the way and no nodes are deleted.
+     *
+     * @param layer
      * @param selection The list of all object to be deleted.
+     * @param simulate  Set to true if the user should not be bugged with additional dialogs
      * @return command A command to perform the deletions, or null of there is nothing to delete.
      */
+    public static Command deleteWithReferences(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection) {
+    public static Command deleteWithReferences(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection, boolean simulate) {
         CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(layer.data);
         for (OsmPrimitive osm : selection) {
 …
         if (v.data.isEmpty())
             return null;
+        if (!checkAndConfirmOutlyingDeletes(layer,v.data))
+        if (!checkAndConfirmOutlyingDeletes(layer,v.data) && !simulate)
             return null;
         return new DeleteCommand(layer,v.data);
+    }
+    private static int testRelation(Relation ref, OsmPrimitive osm) {
+    public static Command deleteWithReferences(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection) {
+        return deleteWithReferences(layer, selection, false);
+    }
+    private static int testRelation(Relation ref, OsmPrimitive osm, boolean simulate) {
+        // If this delete action is simulated, do not bug the user with dialogs
+        // and assume the relations should be deleted
+        if(simulate)
+            return 1;
         String role = new String();
         for (RelationMember m : ref.getMembers()) {
 …
+            }
+        }
+        if (role.length() > 0)
+            return new ExtendedDialog(Main.parent, tr("Conflicting relation"), tr(
+                    "Selection \"{0}\" is used by relation \"{1}\" with role {2}.\nDelete from relation?",
+                    osm.getDisplayName(DefaultNameFormatter.getInstance()), ref.getDisplayName(DefaultNameFormatter.getInstance()), role), new String[] { tr("Delete from relation"),
+                tr("Cancel") }, new String[] { "dialogs/delete.png", "cancel.png" }).getValue();
+        else
+            return new ExtendedDialog(Main.parent, tr("Conflicting relation"), tr(
+                    "Selection \"{0}\" is used by relation \"{1}\".\nDelete from relation?",
+                    osm.getDisplayName(DefaultNameFormatter.getInstance()),
+                    ref.getDisplayName(DefaultNameFormatter.getInstance())), new String[] { tr("Delete from relation"), tr("Cancel") }, new String[] {
+                "dialogs/delete.png", "cancel.png" }).getValue();
+        ExtendedDialog dialog = new ExtendedDialog(
+                Main.parent,
+                tr("Conflicting relation"),
+                new String[] { tr("Delete from relation"),tr("Cancel") }
+        );
+        dialog.setButtonIcons( new String[] { "dialogs/delete.png", "cancel.png" });
+        if (role.length() > 0) {
+            dialog.setContent(
+                    tr(
+                            "<html>Selection \"{0}\" is used by relation \"{1}\" with role {2}.<br>Delete from relation?</html>",
+                            osm.getDisplayName(DefaultNameFormatter.getInstance()),
+                            ref.getDisplayName(DefaultNameFormatter.getInstance()),
+                            role
+                    )
+            );
+            dialog.showDialog();
+            return dialog.getValue();
+        } else {
+            dialog.setContent(
+                    tr(
+                            "<html>Selection \"{0}\" is used by relation \"{1}\".<br>Delete from relation?</html>",
+                            osm.getDisplayName(DefaultNameFormatter.getInstance()),
+                            ref.getDisplayName(DefaultNameFormatter.getInstance())
+                    )
+            );
+            dialog.showDialog();
+            return dialog.getValue();
+        }
+    }
     public static Command delete(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection) {
+        return delete(layer, selection, true);
+        return delete(layer, selection, true, false);
+    }
 …
      * @param selection The objects to delete.
      * @param alsoDeleteNodesInWay <code>true</code> if nodes should be deleted as well
+     * @param simulate Set to true if the user should not be bugged with additional questions
      * @return command a command to perform the deletions, or null if there is nothing to delete.
      */
+    public static Command delete(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection, boolean alsoDeleteNodesInWay) {
+    public static Command delete(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection,
+            boolean alsoDeleteNodesInWay) {
+        return delete(layer, selection, alsoDeleteNodesInWay, false);
+    }
+    public static Command delete(OsmDataLayer layer, Collection<? extends OsmPrimitive> selection,
+            boolean alsoDeleteNodesInWay, boolean simulate) {
         if (selection.isEmpty())
             return null;
 …
+        }
+        if (!checkAndConfirmOutlyingDeletes(layer,primitivesToDelete))
+        if (!simulate && !checkAndConfirmOutlyingDeletes(layer,primitivesToDelete))
             return null;
 …
                     waysToBeChanged.add((Way) ref);
                 } else if (ref instanceof Relation) {
+                    if (testRelation((Relation) ref, osm) == 1) {
+                    if (testRelation((Relation) ref, osm, simulate) == 1) {
                         Collection<OsmPrimitive> relset = relationsToBeChanged.get(ref);
                         if (relset == null) {
 …
+                        }
                         if (!found) {
+                            if (testRelation((Relation) ref, w) == 1) {
+                            if (testRelation((Relation) ref, w, simulate) == 1) {
                                 relset.add(w);
                                 relationsToBeChanged.put(ref, relset);
 …
+            }
             Way w = (Way) primitive;
             if (w.id == 0) { // new ways with id == 0 are fine,
+            if (w.getId() == 0) { // new ways with id == 0 are fine,
                 continue; // process existing ways only
+            }
 …
             // nodes ...
             for (Node n : wnew.getNodes()) {
                 if (n.id != 0 || !primitivesToDelete.contains(n)) {
+                if (n.getId() != 0 || !primitivesToDelete.contains(n)) {
                     nodesToKeep.add(n);
+                }
 …
         if (a != null) {
             for (OsmPrimitive osm : primitivesToDelete) {
                 if (osm instanceof Node && osm.id != 0) {
+                if (osm instanceof Node && osm.getId() != 0) {
                     Node n = (Node) osm;
                     if (!a.contains(n.getCoor())) {

/trunk/src/org/openstreetmap/josm/command/DeletedStateConflictResolveCommand.java

-              r2024
+              r2060
         return new DefaultMutableTreeNode(
                 new JLabel(
                         tr("Resolve conflicts in deleted state in {0}",conflict.getMy().id),
+                        tr("Resolve conflicts in deleted state in {0}",conflict.getMy().getId()),
                         ImageProvider.get("data", "object"),
                         JLabel.HORIZONTAL
 …
         if (decision.equals(MergeDecisionType.KEEP_MINE)) {
             if (conflict.getMy().deleted) {
+            if (conflict.getMy().isDeleted()) {
                 // because my was involved in a conflict it my still be referred
                 // to from a way or a relation. Fix this now.
 …
+            }
         } else if (decision.equals(MergeDecisionType.KEEP_THEIR)) {
             if (conflict.getTheir().deleted) {
+            if (conflict.getTheir().isDeleted()) {
                 layer.data.unlinkReferencesToPrimitive(conflict.getMy());
                 conflict.getMy().delete(true);
             } else {
                 conflict.getMy().deleted = conflict.getTheir().deleted;
+                conflict.getMy().delete(conflict.getTheir().isDeleted());
+            }
         } else

/trunk/src/org/openstreetmap/josm/command/MoveCommand.java

-              r2024
+              r2060
             OldState os = new OldState();
             os.latlon = new LatLon(n.getCoor());
             os.modified = n.modified;
+            os.modified = n.isModified();
             oldState.add(os);
+        }
 …
         for (Node n : nodes) {
             n.setEastNorth(n.getEastNorth().add(x, y));
             n.modified = true;
+            n.setModified(true);
+        }
         return true;
 …
             OldState os = it.next();
             n.setCoor(os.latlon);
             n.modified = os.modified;
+            n.setModified(os.modified);
+        }
+    }

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

-              r2024
+              r2060
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.nio.channels.FileChannel;
 import java.util.ArrayList;
 import java.util.Arrays;
 …
     /**
      * Internal storage for the preferenced directory.
+     * Internal storage for the preference directory.
      * Do not access this variable directly!
      * @see #getPreferencesDirFile()
 …
+    }
+    public File getPreferenceFile() {
+        return new File(getPreferencesDirFile(), "preferences");
+    }
     public File getPluginsDirFile() {
         return new File(getPreferencesDirFile(), "plugins");
 …
                 properties.put(key, value);
+            }
+            save();
+            try {
+                save();
+            } catch(IOException e){
+                System.out.println(tr("Warning: failed to persist preferences to ''{0}''", getPreferenceFile().getAbsoluteFile()));
+            }
             firePreferenceChanged(key, value);
             return true;
 …
      * in log.
      */
+    public void save() {
+    public void save() throws IOException {
         /* currently unused, but may help to fix configuration issues in future */
         properties.put("josm.version", AboutAction.getVersionString());
+        setSystemProperties();
+        File prefFile = new File(getPreferencesDirFile(), "preferences");
+        // Backup old preferences if there are old preferences
+        if(prefFile.exists()) {
+            copyFile(prefFile, new File(prefFile + "_backup"));
+        }
+        final PrintWriter out = new PrintWriter(new OutputStreamWriter(
+                new FileOutputStream(prefFile + "_tmp"), "utf-8"), false);
+        for (final Entry<String, String> e : properties.entrySet()) {
+            String s = defaults.get(e.getKey());
+            /* don't save default values */
+            if(s == null || !s.equals(e.getValue())) {
+                out.println(e.getKey() + "=" + e.getValue());
+            }
+        }
+        out.close();
+        File tmpFile = new File(prefFile + "_tmp");
+        copyFile(tmpFile, prefFile);
+        tmpFile.delete();
+    }
+    /**
+     * Simple file copy function that will overwrite the target file
+     * Taken from http://www.rgagnon.com/javadetails/java-0064.html (CC-NC-BY-SA)
+     * @param in
+     * @param out
+     * @throws IOException
+     */
+    public static void copyFile(File in, File out) throws IOException  {
+        FileChannel inChannel = new FileInputStream(in).getChannel();
+        FileChannel outChannel = new FileOutputStream(out).getChannel();
         try {
+            setSystemProperties();
+            final PrintWriter out = new PrintWriter(new OutputStreamWriter(
+                    new FileOutputStream(getPreferencesDir() + "preferences"), "utf-8"), false);
+            for (final Entry<String, String> e : properties.entrySet()) {
+                String s = defaults.get(e.getKey());
+                /* don't save default values */
+                if(s == null || !s.equals(e.getValue())) {
+                    out.println(e.getKey() + "=" + e.getValue());
+                }
+            }
+            out.close();
+        } catch (final IOException e) {
+            e.printStackTrace();
+            // do not message anything, since this can be called from strange
+            // places.
+        }
+    }
+            inChannel.transferTo(0, inChannel.size(),
+                    outChannel);
+        }
+        catch (IOException e) {
+            throw e;
+        }
+        finally {
+            if (inChannel != null) {
+                inChannel.close();
+            }
+            if (outChannel != null) {
+                outChannel.close();
+            }
+        }
+    }
     public void load() throws IOException {
 …
+    }
+    public void init(Boolean reset)
+    {
+    public void init(boolean reset){
         // get the preferences.
         File prefDir = getPreferencesDirFile();
         if (prefDir.exists()) {
             if(!prefDir.isDirectory()) {
+                System.err.println(tr("Warning: Failed to initialize preferences. Preference directory ''{0}'' isn't a directory.", prefDir.getAbsoluteFile()));
                 JOptionPane.showMessageDialog(
                         Main.parent,
                         tr("Cannot open preferences directory: {0}",Main.pref.getPreferencesDir()),
+                        tr("<html>Failed to initialize preferences.<br>Preference directory ''{0}'' isn't a directory.</html>", prefDir.getAbsoluteFile()),
                         tr("Error"),
                         JOptionPane.ERROR_MESSAGE
 …
+            }
         } else {
+            prefDir.mkdirs();
+        }
+        if (!new File(getPreferencesDir()+"preferences").exists()) {
+            resetToDefault();
+        }
+            if (! prefDir.mkdirs()) {
+                System.err.println(tr("Warning: Failed to initialize preferences. Failed to create missing preference directory: {0}", prefDir.getAbsoluteFile()));
+                JOptionPane.showMessageDialog(
+                        Main.parent,
+                        tr("<html>Failed to initialize preferences.<br>Failed to create missing preference directory: {0}</html>",prefDir.getAbsoluteFile()),
+                        tr("Error"),
+                        JOptionPane.ERROR_MESSAGE
+                );
+                return;
+            }
+        }
+        File preferenceFile = getPreferenceFile();
         try {
+            if (reset) {
+            if (!preferenceFile.exists()) {
+                System.out.println(tr("Warning: Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
                 resetToDefault();
+            } else {
+                load();
+            }
+        } catch (final IOException e1) {
+            e1.printStackTrace();
+            String backup = getPreferencesDir() + "preferences.bak";
+                save();
+            } else if (reset) {
+                System.out.println(tr("Warning: Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
+                resetToDefault();
+                save();
+            }
+        } catch(IOException e) {
+            e.printStackTrace();
             JOptionPane.showMessageDialog(
                     Main.parent,
                     tr("Preferences file had errors. Making backup of old one to {0}.", backup),
+                    tr("<html>Failed to initialize preferences.<br>Failed to reset preference file to default: {0}</html>",getPreferenceFile().getAbsoluteFile()),
                     tr("Error"),
                     JOptionPane.ERROR_MESSAGE
             );
+            new File(getPreferencesDir() + "preferences").renameTo(new File(backup));
+            save();
+        }
+    }
+    public final void resetToDefault() {
+            return;
+        }
+        try {
+            load();
+        } catch (IOException e) {
+            e.printStackTrace();
+            File backupFile = new File(prefDir,"preferences.bak");
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("<html>Preferences file had errors.<br> Making backup of old one to <br>{0}<br> and creating a new default preference file.</html>", backupFile.getAbsoluteFile()),
+                    tr("Error"),
+                    JOptionPane.ERROR_MESSAGE
+            );
+            preferenceFile.renameTo(backupFile);
+            try {
+                resetToDefault();
+                save();
+            } catch(IOException e1) {
+                e1.printStackTrace();
+                System.err.println(tr("Warning: Failed to initialize preferences.Failed to reset preference file to default: {0}", getPreferenceFile()));
+            }
+        }
+    }
+    public final void resetToDefault(){
         properties.clear();
         put("layerlist.visible", true);
 …
             put("laf", "com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
+        }
+        save();
+    }
+    public File getBookmarksFile() {
+        return new File(getPreferencesDir(),"bookmarks");
+    }
     public Collection<Bookmark> loadBookmarks() throws IOException {
         File bookmarkFile = new File(getPreferencesDir()+"bookmarks");
+        File bookmarkFile = getBookmarksFile();
         if (!bookmarkFile.exists()) {
             bookmarkFile.createNewFile();

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

-              r2024
+              r2060
         if (Main.map != null && Main.map.mapView.getActiveLayer() instanceof OsmDataLayer) {
             OsmDataLayer data = (OsmDataLayer)Main.map.mapView.getActiveLayer();
-            data.setModified(true);
             data.fireDataChange();
+        }
 …
         if (Main.map != null && Main.map.mapView.getActiveLayer() instanceof OsmDataLayer) {
             OsmDataLayer data = (OsmDataLayer)Main.map.mapView.getActiveLayer();
-            data.setModified(data.uploadedModified || !commands.isEmpty());
             data.fireDataChange();
+        }
 …
         if (Main.map != null && Main.map.mapView.getActiveLayer() instanceof OsmDataLayer) {
             OsmDataLayer data = (OsmDataLayer)Main.map.mapView.getActiveLayer();
-            data.setModified(true);
             data.fireDataChange();
+        }

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

-              r2024
+              r2060
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
             if (osm.visible && !osm.deleted) {
+            if (osm.isVisible() && !osm.isDeleted()) {
                 o.add(osm);
+            }
 …
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
             if (osm.visible && !osm.deleted && !osm.incomplete) {
+            if (osm.isVisible() && !osm.isDeleted() && !osm.incomplete) {
                 o.add(osm);
+            }
 …
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
             if (osm.visible && !osm.deleted && !osm.incomplete && !(osm instanceof Relation)) {
+            if (osm.isVisible() && !osm.isDeleted() && !osm.incomplete && !(osm instanceof Relation)) {
                 o.add(osm);
+            }
 …
             return sel;
         for (OsmPrimitive osm : list)
             if (osm.isSelected() && !osm.deleted) {
+            if (osm.isSelected() && !osm.isDeleted()) {
                 sel.add(osm);
+            }
 …
                     String as = h.get(a);
                     if (as == null) {
                         as = a.getName() != null ? a.getName() : Long.toString(a.id);
+                        as = a.getName() != null ? a.getName() : Long.toString(a.getId());
                         h.put(a, as);
+                    }
                     String bs = h.get(b);
                     if (bs == null) {
                         bs = b.getName() != null ? b.getName() : Long.toString(b.id);
+                        bs = b.getName() != null ? b.getName() : Long.toString(b.getId());
                         h.put(b, bs);
+                    }
 …
             throw new IllegalArgumentException(tr("parameter {0} > 0 required. Got {1}.", "id", id));
         for (OsmPrimitive primitive : nodes) {
             if (primitive.id == id) return primitive;
+            if (primitive.getId() == id) return primitive;
+        }
         for (OsmPrimitive primitive : ways) {
             if (primitive.id == id) return primitive;
+            if (primitive.getId() == id) return primitive;
+        }
         for (OsmPrimitive primitive : relations) {
             if (primitive.id == id) return primitive;
+            if (primitive.getId() == id) return primitive;
+        }
         return null;
 …
         HashSet<Long> ret = new HashSet<Long>();
         for (OsmPrimitive primitive : nodes) {
             ret.add(primitive.id);
+            ret.add(primitive.getId());
+        }
         for (OsmPrimitive primitive : ways) {
             ret.add(primitive.id);
+            ret.add(primitive.getId());
+        }
         for (OsmPrimitive primitive : relations) {
             ret.add(primitive.id);
+            ret.add(primitive.getId());
+        }
         return ret;
 …
     /**
      * Replies the set of ids of all complete primitivies (i.e. those with
+     * Replies the set of ids of all complete primitives (i.e. those with
      * ! primitive.incomplete)
+     *
      * @return the set of ids of all complete primitivies
+     * @return the set of ids of all complete primitives
      */
     public Set<Long> getCompletePrimitiveIds() {
 …
         for (OsmPrimitive primitive : nodes) {
             if (!primitive.incomplete) {
                 ret.add(primitive.id);
+                ret.add(primitive.getId());
+            }
+        }
         for (OsmPrimitive primitive : ways) {
             if (! primitive.incomplete) {
                 ret.add(primitive.id);
+                ret.add(primitive.getId());
+            }
+        }
         for (OsmPrimitive primitive : relations) {
             if (! primitive.incomplete) {
                 ret.add(primitive.id);
+                ret.add(primitive.getId());
+            }
+        }
 …
         return parents;
+    }
+    /**
+     * Replies true if there is at least one primitive in this dataset with
+     * {@see OsmPrimitive#isModified()} == <code>true</code>.
+     *
+     * @return true if there is at least one primitive in this dataset with
+     * {@see OsmPrimitive#isModified()} == <code>true</code>.
+     */
+    public boolean isModified() {
+        for (Node n: nodes) {
+            if (n.isModified()) return true;
+        }
+        for (Way w: ways) {
+            if (w.isModified()) return true;
+        }
+        for (Relation r: relations) {
+            if (r.isModified()) return true;
+        }
+        return false;
+    }
+}

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

-              r2024
+              r2060
      * new to the server! To create a new object, call the default constructor of
      * the respective class.
+     */
+     *
+     * @deprecated use {@see #getId()}. Don't assign an id, create a primitive with
+     * the respective constructors.
+     */
+    @Deprecated
     public long id = 0;
 …
      * Deleted objects are deleted from the server. If the objects are added (id=0),
      * the modified is ignored and the object is added to the server.
+     */
+     *
+     * @deprecated Please use {@see #setModified()} and {@see #getModified()}
+     */
+    @Deprecated
     public boolean modified = false;
     /**
      * <code>true</code>, if the object has been deleted.
+     */
+     *
+     * @deprecated use {@see #delete()} and {@see #isDeleted()}
+     */
+    @Deprecated
     public boolean deleted = false;
 …
      * introduced with the 0.4 API to be able to communicate deleted objects
      * (they will have visible=false).
+     */
+     *
+     * @deprecated use {@see #isVisible()} and {@see #setVisible(boolean)}
+     */
+    @Deprecated
     public boolean visible = true;
 …
     /**
      * If set to true, this object is currently selected.
+     *
+     * @deprecated use {@see #isSelected()} and {@see #setSelected(boolean)}
      */
     @Deprecated
 …
     public boolean isSelected() {
         return selected;
+    }
+    /**
+     * Marks this primitive as being modified.
+     *
+     * @param modified true, if this primitive is to be modified
+     */
+    public void setModified(boolean modified) {
+        this.modified = modified;
+    }
+    /**
+     * Replies <code>true</code> if the object has been modified since it was loaded from
+     * the server. In this case, on next upload, this object will be updated.
+     *
+     * @return <code>true</code> if the object has been modified since it was loaded from
+     * the server
+     */
+    public boolean isModified() {
+        return modified;
+    }
+    /**
+     * Replies <code>true</code>, if the object has been deleted.
+     *
+     * @return <code>true</code>, if the object has been deleted.
+     * @see #delete(boolean)
+     */
+    public boolean isDeleted() {
+        return deleted;
+    }
+    /**
+     * Replies true if this primitive is either unknown to the server (i.e. its id
+     * is 0) or it is known to the server and it hasn't be deleted on the server.
+     * Replies false, if this primitive is known on the server and has been deleted
+     * on the server.
+     *
+     * @see #setVisible(boolean)
+     */
+    public boolean isVisible() {
+        return visible;
+    }
+    /**
+     * Sets whether this primitive is visible, i.e. whether it is known on the server
+     * and not deleted on the server.
+     *
+     * @see #isVisible()
+     * @throws IllegalStateException thrown if visible is set to false on an primitive with
+     * id==0
+     */
+    public void setVisible(boolean visible) throws IllegalStateException{
+        if (id == 0 && visible == false)
+            throw new IllegalStateException(tr("a primitive with id=0 can't be invisible"));
+        this.visible = visible;
+    }
+    /**
+     * Replies the id of this primitive.
+     *
+     * @return the id of this primitive.
+     */
+    public long getId() {
+        return id;
+    }
 …
      */
     public abstract String getDisplayName(NameFormatter formatter);
+}

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

-              r2024
+              r2060
         return user;
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
+        result = prime * result + ((uid == null) ? 0 : uid.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        User other = (User) obj;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        if (uid == null) {
+            if (other.uid != null)
+                return false;
+        } else if (!uid.equals(other.uid))
+            return false;
+        return true;
+    }
+}

/trunk/src/org/openstreetmap/josm/data/osm/visitor/CreateOsmChangeVisitor.java

-              r2024
+              r2060
     public void visit(Node n) {
         if (n.deleted) {
+        if (n.isDeleted()) {
             switchMode("delete");
             osmwriter.setWithBody(false);
             osmwriter.visit(n);
         } else {
             switchMode((n.id == 0) ? "create" : "modify");
+            switchMode((n.getId() == 0) ? "create" : "modify");
             osmwriter.setWithBody(true);
             osmwriter.visit(n);
 …
+    }
     public void visit(Way w) {
         if (w.deleted) {
+        if (w.isDeleted()) {
             switchMode("delete");
             osmwriter.setWithBody(false);
             osmwriter.visit(w);
         } else {
             switchMode((w.id == 0) ? "create" : "modify");
+            switchMode((w.getId() == 0) ? "create" : "modify");
             osmwriter.setWithBody(true);
             osmwriter.visit(w);
 …
+    }
     public void visit(Relation r) {
         if (r.deleted) {
+        if (r.isDeleted()) {
             switchMode("delete");
             osmwriter.setWithBody(false);
             osmwriter.visit(r);
         } else {
             switchMode((r.id == 0) ? "create" : "modify");
+            switchMode((r.getId() == 0) ? "create" : "modify");
             osmwriter.setWithBody(true);
             osmwriter.visit(r);

/trunk/src/org/openstreetmap/josm/data/osm/visitor/MapPaintVisitor.java

-              r2024
+              r2060
             for (RelationMember m : r.getMembers())
+            {
                 if (m.isNode() && !m.getMember().incomplete && !m.getMember().deleted)
+                if (m.isNode() && !m.getMember().incomplete && !m.getMember().isDeleted())
+                {
                     drawSelectedMember(m.getMember(), styles != null ? getPrimitiveStyle(m.getMember()) : null, true, true);
 …
             for (RelationMember m : r.getMembers())
+            {
                 if (m.isWay() && !m.getMember().incomplete && !m.getMember().deleted) /* nodes drawn on second call */
+                if (m.isWay() && !m.getMember().incomplete && !m.getMember().isDeleted()) /* nodes drawn on second call */
+                {
                     drawSelectedMember(m.getMember(), styles != null ? getPrimitiveStyle(m.getMember())
 …
                 // TODO Nullable member will not be allowed after RelationMember.member is encalupsed
                 r.putError(tr("Empty member in relation."), true);
             } else if(m.getMember().deleted) {
+            } else if(m.getMember().isDeleted()) {
                 r.putError(tr("Deleted member ''{0}'' in relation.",
                         m.getMember().getDisplayName(DefaultNameFormatter.getInstance())), true);
 …
                 //TODO Remove useless nullcheck when RelationMember.member is encalupsed
                 r.putError(tr("Empty member in relation."), true);
             } else if(m.getMember().deleted) {
+            } else if(m.getMember().isDeleted()) {
                 r.putError(tr("Deleted member ''{0}'' in relation.",
                         m.getMember().getDisplayName(DefaultNameFormatter.getInstance())), true);
 …
             for (final Relation osm : data.relations)
+            {
                 if(!osm.deleted && !osm.incomplete && osm.mappaintVisibleCode != viewid)
+                if(!osm.isDeleted() && !osm.incomplete && osm.mappaintVisibleCode != viewid)
+                {
                     osm.visit(this);
 …
             for (final Way osm : data.ways)
+            {
                 if (!osm.incomplete && !osm.deleted
+                if (!osm.incomplete && !osm.isDeleted()
                         && osm.mappaintVisibleCode != viewid && osm.mappaintDrawnCode != paintid)
+                {
 …
             //    profilerN = 0;
             for (final OsmPrimitive osm : data.ways)
                 if (!osm.incomplete && !osm.deleted && !osm.isSelected()
+                if (!osm.incomplete && !osm.isDeleted() && !osm.isSelected()
                         && osm.mappaintVisibleCode != viewid )
+                {
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.getSelected()) {
             if (!osm.incomplete && !osm.deleted && !(osm instanceof Node)
+            if (!osm.incomplete && !osm.isDeleted() && !(osm instanceof Node)
                     && osm.mappaintVisibleCode != viewid && osm.mappaintDrawnCode != paintid)
+            {
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.nodes)
             if (!osm.incomplete && !osm.deleted
+            if (!osm.incomplete && !osm.isDeleted()
                     && osm.mappaintVisibleCode != viewid && osm.mappaintDrawnCode != paintid)
+            {
 …
             currentColor = nodeColor;
             for (final OsmPrimitive osm : data.ways)
                 if (!osm.incomplete && !osm.deleted
+                if (!osm.incomplete && !osm.isDeleted()
                         && osm.mappaintVisibleCode != viewid )
+                {

/trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java

-              r2024
+              r2060
         for (RelationMember member: r.getMembers()) {
             newMembers.add(
+                new RelationMember(member.getRole(), mappedPrimitives.get(member.getMember())));
+                    new RelationMember(member.getRole(), mappedPrimitives.get(member.getMember())));
+        }
 …
         OsmPrimitive clone = null;
         if (primitive instanceof Node) {
             clone = new Node(primitive.id);
+            clone = new Node(primitive.getId());
         } else if (primitive instanceof Way) {
             clone = new Way(primitive.id);
+            clone = new Way(primitive.getId());
         } else if (primitive instanceof Relation) {
             clone = new Relation(primitive.id);
+            clone = new Relation(primitive.getId());
+        }
         clone.incomplete = true;
 …
     protected boolean isNew(OsmPrimitive primitive) {
         return primitive.id == 0;
+        return primitive.getId() == 0;
+    }

/trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

-              r2024
+              r2060
         this.theirDataSet = theirDataSet;
         for (Node n : myDataSet.nodes) if (n.id != 0) {
             nodeshash.put(n.id, n);
+        }
         for (Way w : myDataSet.ways) if (w.id != 0) {
             wayshash.put(w.id, w);
+        }
         for (Relation r : myDataSet.relations) if (r.id != 0) {
             relshash.put(r.id, r);
+        for (Node n : myDataSet.nodes) if (n.getId() != 0) {
+            nodeshash.put(n.getId(), n);
+        }
+        for (Way w : myDataSet.ways) if (w.getId() != 0) {
+            wayshash.put(w.getId(), w);
+        }
+        for (Relation r : myDataSet.relations) if (r.getId() != 0) {
+            relshash.put(r.getId(), r);
+        }
         conflicts = new ConflictCollection();
 …
             HashMap<Long, P> primitivesWithDefinedIds) {
         if (other.id > 0 ) {
+        if (other.getId() > 0 ) {
             // try to merge onto a matching primitive with the same
             // defined id
 …
             //
             for (P my : myPrimitives) {
                 if (my.id >0 ) {
+                if (my.getId() >0 ) {
                     continue;
+                }
                 if (my.hasEqualSemanticAttributes(other)) {
                     if (my.deleted != other.deleted) {
+                    if (my.isDeleted() != other.isDeleted()) {
                         // differences in deleted state have to be merged manually
                         //
 …
                         // copy the technical attributes from other
                         // version
                         my.visible = other.visible;
+                        my.setVisible(other.isVisible());
                         my.user = other.user;
                         my.setTimestamp(other.getTimestamp());
                         my.modified = other.modified;
+                        my.setModified(other.isModified());
                         merged.put(other, my);
+                    }
 …
             Node mergedNode = (Node) merged.get(myNode);
             if (mergedNode != null) {
                 if (!mergedNode.deleted) {
+                if (!mergedNode.isDeleted()) {
                     newNodes.add(mergedNode);
+                }
 …
                 newMembers.add(myMember);
             } else {
                 if (! mergedMember.deleted) {
+                if (! mergedMember.isDeleted()) {
                     RelationMember newMember = new RelationMember(myMember.getRole(), mergedMember);
                     newMembers.add(newMember);
 …
         // merge other into an existing primitive with the same id, if possible
         //
         if (myPrimitivesWithDefinedIds.containsKey(other.id)) {
             P my = myPrimitivesWithDefinedIds.get(other.id);
+        if (myPrimitivesWithDefinedIds.containsKey(other.getId())) {
+            P my = myPrimitivesWithDefinedIds.get(other.getId());
             if (my.version <= other.version) {
                 if (! my.visible && other.visible) {
+                if (! my.isVisible() && other.isVisible()) {
                     // should not happen
                     //
 …
                             + "their primitive with lower version {2} is not visible. "
                             + "Can't deal with this inconsistency. Keeping my primitive. ",
                             Long.toString(my.id),Long.toString(my.version), Long.toString(other.version)
+                            Long.toString(my.getId()),Long.toString(my.version), Long.toString(other.version)
                     ));
                     merged.put(other, my);
                 } else if (my.visible && ! other.visible) {
+                } else if (my.isVisible() && ! other.isVisible()) {
                     // this is always a conflict because the user has to decide whether
                     // he wants to create a clone of its local primitive or whether he
 …
                     //
                     merged.put(other, my);
                 } else if (my.deleted && ! other.deleted && my.version == other.version) {
+                } else if (my.isDeleted() && ! other.isDeleted() && my.version == other.version) {
                     // same version, but my is deleted. Assume mine takes precedence
                     // otherwise too many conflicts when refreshing from the server
                     merged.put(other, my);
                 } else if (my.deleted != other.deleted) {
+                } else if (my.isDeleted() != other.isDeleted()) {
                     // differences in deleted state have to be resolved manually
                     //
                     conflicts.add(my,other);
                 } else if (! my.modified && other.modified) {
+                } else if (! my.isModified() && other.isModified()) {
                     // my not modified. We can assume that other is the most recent version.
                     // clone it onto my. But check first, whether other is deleted. if so,
                     // make sure that my is not references anymore in myDataSet.
                     //
                     if (other.deleted) {
+                    if (other.isDeleted()) {
                         myDataSet.unlinkReferencesToPrimitive(my);
+                    }
                     my.cloneFrom(other);
                     merged.put(other, my);
                 } else if (! my.modified && !other.modified && my.version == other.version) {
+                } else if (! my.isModified() && !other.isModified() && my.version == other.version) {
                     // both not modified. Keep mine
                     //
                     merged.put(other,my);
                 } else if (! my.modified && !other.modified && my.version < other.version) {
+                } else if (! my.isModified() && !other.isModified() && my.version < other.version) {
                     // my not modified but other is newer. clone other onto mine.
                     //
                     my.cloneFrom(other);
                     merged.put(other,my);
                 } else if (my.modified && ! other.modified && my.version == other.version) {
+                } else if (my.isModified() && ! other.isModified() && my.version == other.version) {
                     // my is same as other but mine is modified
                     // => keep mine
 …
                     //
                     my.cloneFrom(other);
                     my.modified = true;
+                    my.setModified(true);
                     merged.put(other, my);
+                }

/trunk/src/org/openstreetmap/josm/data/osm/visitor/SimplePaintVisitor.java

-              r2024
+              r2060
     /**
      * Preferences
+    */
+     */
     protected Color inactiveColor;
     protected Color selectedColor;
 …
         ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+            Main.pref.getBoolean("mappaint.use-antialiasing", false) ?
+            RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
+                Main.pref.getBoolean("mappaint.use-antialiasing", false) ?
+                        RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
+    }
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.relations)
             if (!osm.deleted && !osm.isSelected())
+            if (!osm.isDeleted() && !osm.isSelected())
+            {
                 osm.visit(this);
+        //        profilerN++;
+                //        profilerN++;
+            }
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.ways)
             if (!osm.deleted && !osm.isSelected() && osm.isTagged())
+            if (!osm.isDeleted() && !osm.isSelected() && osm.isTagged())
+            {
                 osm.visit(this);
+        //        profilerN++;
+                //        profilerN++;
+            }
         displaySegments();
         for (final OsmPrimitive osm : data.ways)
             if (!osm.deleted && !osm.isSelected() && !osm.isTagged())
+            if (!osm.isDeleted() && !osm.isSelected() && !osm.isTagged())
+            {
                 osm.visit(this);
+        //        profilerN++;
+                //        profilerN++;
+            }
         displaySegments();
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.getSelected())
             if (!osm.deleted)
+            if (!osm.isDeleted())
+            {
                 osm.visit(this);
+        //        profilerN++;
+                //        profilerN++;
+            }
         displaySegments();
 …
         //profilerN = 0;
         for (final OsmPrimitive osm : data.nodes)
             if (!osm.deleted && !osm.isSelected())
+            if (!osm.isDeleted() && !osm.isSelected())
+            {
                 osm.visit(this);
+        //        profilerN++;
+                //        profilerN++;
+            }
 …
         if(virtualNodeSize != 0)
+        {
+        //    profilerN = 0;
+            //    profilerN = 0;
             currentColor = nodeColor;
             for (final OsmPrimitive osm : data.ways)
                 if (!osm.deleted)
+                    {
                         visitVirtual((Way)osm);
+        //                profilerN++;
+                    }
+                if (!osm.isDeleted())
+                {
+                    visitVirtual((Way)osm);
+                    //                profilerN++;
+                }
             displaySegments();
+        //    if(profiler)
+        //    {
+        //        System.out.format("Virtual  : %4dms, n=%5d\n", (java.lang.System.currentTimeMillis()-profilerLast), profilerN);
+        //        profilerLast = java.lang.System.currentTimeMillis();
+        //    }
+            //    if(profiler)
+            //    {
+            //        System.out.format("Virtual  : %4dms, n=%5d\n", (java.lang.System.currentTimeMillis()-profilerLast), profilerN);
+            //        profilerLast = java.lang.System.currentTimeMillis();
+            //    }
+        }
 …
         if (n.incomplete) return;
+        if (inactive)
+        if (inactive) {
             drawNode(n, inactiveColor, unselectedNodeSize, unselectedNodeRadius, fillUnselectedNode);
+        else if (n.highlighted)
+        } else if (n.highlighted) {
             drawNode(n, highlightColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
+        else if (n.isSelected())
+        } else if (n.isSelected()) {
             drawNode(n, selectedColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
+        else if(n.isTagged())
+        } else if(n.isTagged()) {
             drawNode(n, nodeColor, taggedNodeSize, taggedNodeRadius, fillUnselectedNode);
         else
+        } else {
             drawNode(n, nodeColor, unselectedNodeSize, unselectedNodeRadius, fillUnselectedNode);
+        }
+    }
     public static Boolean isLargeSegment(Point p1, Point p2, int space)
+    {
+        int xd = p1.x-p2.x; if(xd < 0) xd = -xd;
+        int yd = p1.y-p2.y; if(yd < 0) yd = -yd;
+        int xd = p1.x-p2.x; if(xd < 0) {
+            xd = -xd;
+        }
+        int yd = p1.y-p2.y; if(yd < 0) {
+            yd = -yd;
+        }
         return (xd+yd > space);
+    }
 …
                 Point p = nc.getPoint(it.next());
                 drawSegment(lastP, p, wayColor,
+                    showOnlyHeadArrowOnly ? !it.hasNext() : showThisDirectionArrow);
+                if (showOrderNumber)
+                        showOnlyHeadArrowOnly ? !it.hasNext() : showThisDirectionArrow);
+                if (showOrderNumber) {
                     drawOrderNumber(lastP, p, orderNumber);
+                }
                 lastP = p;
+            }
 …
     private Stroke relatedWayStroke = new BasicStroke(
+, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL);
+, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL);
     public void visit(Relation r) {
         if (r.incomplete) return;
 …
         for (RelationMember m : r.getMembers()) {
+            if (m.getMember().incomplete || m.getMember().deleted) continue;
+            if (m.getMember().incomplete || m.getMember().isDeleted()) {
+                continue;
+            }
             if (m.isNode()) {
                 Point p = nc.getPoint(m.getNode());
                 if (p.x < 0 || p.y < 0
+                    || p.x > nc.getWidth() || p.y > nc.getHeight()) continue;
+                        || p.x > nc.getWidth() || p.y > nc.getHeight()) {
+                    continue;
+                }
                 g.drawOval(p.x-3, p.y-3, 6, 6);
 …
                 boolean first = true;
                 for (Node n : m.getWay().getNodes()) {
+                    if (n.incomplete || n.deleted) continue;
+                    if (n.incomplete || n.isDeleted()) {
+                        continue;
+                    }
                     Point p = nc.getPoint(n);
                     if (first) {
 …
                 g.fillRect(p.x - radius, p.y - radius, size, size);
                 g.drawRect(p.x - radius, p.y - radius, size, size);
+            } else
+            } else {
                 g.drawRect(p.x - radius, p.y - radius, size, size);
+            }
+        }
+    }
 …
      */
     protected void drawSegment(Point p1, Point p2, Color col, boolean showDirection) {
+        if (col != currentColor) displaySegments(col);
+        if (col != currentColor) {
+            displaySegments(col);
+        }
         if (isSegmentVisible(p1, p2)) {

/trunk/src/org/openstreetmap/josm/gui/BookmarkList.java

-              r2024
+              r2060
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.Preferences;
+import sun.security.action.GetBooleanAction;
 /**
 …
             JOptionPane.showMessageDialog(
                     Main.parent,
+                    tr("<html>Could not read bookmarks.<br>{0}</html>", e.getMessage()),
+                    tr("<html>Could not read bookmarks from<br>''{0}''<br>Error was: {1}</html>",
+                            Main.pref.getBookmarksFile(),
+                            e.getMessage()
+                    ),
                     tr("Error"),
                     JOptionPane.ERROR_MESSAGE

/trunk/src/org/openstreetmap/josm/gui/ConditionalOptionPaneUtil.java

r2024	r2060
27	27	*
28	28	*/
29		public class ConditionalOptionPaneUtil {
	29	@Deprecated public class ConditionalOptionPaneUtil {
30	30	static public final int DIALOG_DISABLED_OPTION = Integer.MIN_VALUE;
31	31

/trunk/src/org/openstreetmap/josm/gui/ExceptionDialogUtil.java

-              r2024
+              r2060
 import org.openstreetmap.josm.io.OsmApiException;
 import org.openstreetmap.josm.io.OsmApiInitializationException;
+import org.openstreetmap.josm.io.OsmChangesetCloseException;
 import org.openstreetmap.josm.io.OsmTransferException;
 …
         JOptionPane.showMessageDialog(
                 Main.parent,
+                tr(   "Failed to initialize communication with the OSM server {0}.\n"
+                        + "Check the server URL in your preferences and your internet connection.",
+                tr(   "<html>Failed to initialize communication with the OSM server {0}.<br>"
+                        + "Check the server URL in your preferences and your internet connection.</html>",
+                        Main.pref.get("osm-server.url", "http://api.openstreetmap.org/api")
+                ),
+                tr("Error"),
+                JOptionPane.ERROR_MESSAGE
+        );
+    }
+    /**
+     * handles an exception caught during OSM API initialization
+     *
+     * @param e the exception
+     */
+    public static void explainOsmChangesetCloseException(OsmChangesetCloseException e) {
+        e.printStackTrace();
+        String changsetId = e.getChangeset() == null ? tr("unknown") : Long.toString(e.getChangeset().getId());
+        JOptionPane.showMessageDialog(
+                Main.parent,
+                tr(   "<html>Failed to close changeset ''{0}'' on the OSM server ''{1}''.<br>"
+                        + "The changeset will automatically be closed by the server after a timeout.</html>",
+                        changsetId,
                         Main.pref.get("osm-server.url", "http://api.openstreetmap.org/api")
                 ),
 …
             return;
+        }
+        if (e instanceof OsmChangesetCloseException){
+            explainOsmChangesetCloseException((OsmChangesetCloseException)e);
+            return;
+        }
         if (e instanceof OsmApiException) {
             OsmApiException oae = (OsmApiException)e;

/trunk/src/org/openstreetmap/josm/gui/ExtendedDialog.java

-              r2024
+              r2060
 package org.openstreetmap.josm.gui;
+import static org.openstreetmap.josm.tools.I18n.tr;
 import java.awt.Component;
+import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.Frame;
 import java.awt.GridBagLayout;
 import java.awt.Toolkit;
 …
 import javax.swing.Action;
 import javax.swing.JButton;
+import javax.swing.JCheckBox;
 import javax.swing.JComponent;
 import javax.swing.JDialog;
 …
 import javax.swing.KeyStroke;
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.ImageProvider;
 …
 public class ExtendedDialog extends JDialog {
     private int result = 0;
+    public static final int DialogNotShown = -99;
+    public static final int DialogClosedOtherwise = 0;
+    private boolean toggleable = false;
+    private String togglePref = "";
+    private String toggleCheckboxText = tr("Do not show again");
+    private JCheckBox toggleCheckbox = null;
     private Component parent;
+    private Component content;
     private final String[] bTexts;
+    private String[] bIcons;
+    /**
+     * set to true if the content of the extended dialog should
+     * be placed in a {@see JScrollPane}
+     */
+    private boolean placeContentInScrollPane;
     // For easy access when inherited
     protected Object contentConstraints = GBC.eol().anchor(GBC.CENTER).fill(GBC.HORIZONTAL).insets(5,10,5,0);
+    protected Object contentConstraints = GBC.eol().anchor(GBC.CENTER).fill(GBC.BOTH).insets(5,10,5,0);
     protected ArrayList<JButton> buttons = new ArrayList<JButton>();
+    /**
+     * This method sets up the most basic options for the dialog. Add all more
+     * advanced features with dedicated methods.
+     * Possible features:
+     * <ul>
+     *   <li><code>setButtonIcons</code></li>
+     *   <li><code>setContent</code></li>
+     *   <li><code>toggleEnable</code></li>
+     *   <li><code>toggleDisable</code></li>
+     *   <li><code>setToggleCheckboxText</code></li>
+     * </ul>
+     *
+     * When done, call <code>showDialog</code> to display it. You can receive
+     * the user's choice using <code>getValue</code>. Have a look at this function
+     * for possible return values.
+     *
+     * @param parent       The parent element that will be used for position and maximum size
+     * @param title        The text that will be shown in the window titlebar
+     * @param buttonTexts  String Array of the text that will appear on the buttons. The first button is the default one.
+     */
+    public ExtendedDialog(Component parent, String title, String[] buttonTexts) {
+        super(JOptionPane.getFrameForComponent(parent), title, true);
+        this.parent = parent;
+        bTexts = buttonTexts;
+    }
+    /**
+     * Same as above but lets you define if the dialog should be modal.
+     */
+    public ExtendedDialog(Component parent, String title, String[] buttonTexts,
+            boolean modal) {
+        super(JOptionPane.getFrameForComponent(parent), title, modal);
+        this.parent = parent;
+        bTexts = buttonTexts;
+    }
     /**
 …
      * @param buttonIcons The path to the icons that will be displayed on the buttons. Path is relative to JOSM's image directory. File extensions need to be included. If a button should not have an icon pass null.
      */
+    public ExtendedDialog(Component parent, String title, Component content, String[] buttonTexts, String[] buttonIcons) {
+    @Deprecated public ExtendedDialog(Component parent, String title, Component content,
+            String[] buttonTexts, String[] buttonIcons) {
         super(JOptionPane.getFrameForComponent(parent), title, true /* modal */);
         this.parent = parent;
         bTexts = buttonTexts;
+        setupDialog(content, buttonIcons);
+        this.content = content;
+        this.bIcons = buttonIcons;
+        setupDialog();
         setVisible(true);
+    }
+    public ExtendedDialog(Component parent, String title, Component content, String[] buttonTexts) {
+    @Deprecated public ExtendedDialog(Component parent, String title, Component content,
+            String[] buttonTexts) {
         this(parent, title, content, buttonTexts, null);
+    }
 …
      * Sets up the dialog and displays the given message in a breakable label
      */
+    public ExtendedDialog(Component parent, String title, String message, String[] buttonTexts, String[] buttonIcons) {
+        super(JOptionPane.getFrameForComponent(parent), title, true);
+        JMultilineLabel lbl = new JMultilineLabel(message);
+        // Make it not wider than 2/3 of the screen
+        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        lbl.setMaxWidth(Math.round(screenSize.width*2/3));
+        this.parent = parent;
+        bTexts = buttonTexts;
+        setupDialog(lbl, buttonIcons);
+    @Deprecated public ExtendedDialog(Component parent, String title, String message,
+            String[] buttonTexts, String[] buttonIcons) {
+        this(parent, title, string2label(message), buttonTexts, buttonIcons);
+    }
+    @Deprecated public ExtendedDialog(Component parent, String title, String message,
+            String[] buttonTexts) {
+        this(parent, title, message, buttonTexts, null);
+    }
+    /**
+     * Allows decorating the buttons with icons. Expects an String[] with paths
+     * to images relative to JOSM/images.
+     * @param buttonIcons
+     */
+    public void setButtonIcons(String[] buttonIcons) {
+        this.bIcons = buttonIcons;
+    }
+    /**
+     * Sets the content that will be displayed in the message dialog.
+     *
+     * Note that depending on your other settings more UI elements may appear.
+     * The content is played on top of the other elements though.
+     *
+     * @param content Any element that can be displayed in the message dialog
+     */
+    public void setContent(Component content) {
+        setContent(content, true);
+    }
+    /**
+     * Sets the content that will be displayed in the message dialog.
+     *
+     * Note that depending on your other settings more UI elements may appear.
+     * The content is played on top of the other elements though.
+     *
+     * @param content Any element that can be displayed in the message dialog
+     * @param placeContentInScrollPane if  true, places  the content in a JScrollPane
+     *
+     */
+    public void setContent(Component content, boolean placeContentInScrollPane) {
+        this.content = content;
+        this.placeContentInScrollPane = placeContentInScrollPane;
+    }
+    /**
+     * Sets the message that will be displayed. The String will be automatically
+     * wrapped if it is too long.
+     *
+     * Note that depending on your other settings more UI elements may appear.
+     * The content is played on top of the other elements though.
+     *
+     * @param message The text that should be shown to the user
+     */
+    public void setContent(String message) {
+        setContent(string2label(message), true);
+    }
+    /**
+     * Show the dialog to the user. Call this after you have set all options
+     * for the dialog. You can retrieve the result using <code>getValue</code>
+     */
+    public void showDialog() {
+        // Check if the user has set the dialog to not be shown again
+        if(toggleCheckState(togglePref)) {
+            result = ExtendedDialog.DialogNotShown;
+            return;
+        }
+        setupDialog();
         setVisible(true);
+    }
+    public ExtendedDialog(Component parent, String title, String message, String[] buttonTexts) {
+        this(parent, title, message, buttonTexts, null);
+    }
+    /**
+     * Constructor that doesn't make the dialog visible immediately. Intended for when inheriting.
+     */
+    public ExtendedDialog(Component parent, String title, String[] buttonTexts, boolean modal) {
+        super(JOptionPane.getFrameForComponent(parent), title, modal);
+        this.parent = parent;
+        bTexts = buttonTexts;
+    }
+    protected void setupDialog(Component content, String[] buttonIcons) {
+        toggleSaveState();
+    }
+    /**
+     * @return int * The selected button. The count starts with 1.
+     *             * A return value of ExtendedDialog.DialogClosedOtherwise means the dialog has been closed otherwise.
+     *             * A return value of ExtendedDialog.DialogNotShown means the
+     *               dialog has been toggled off in the past
+     */
+    public int getValue() {
+        return result;
+    }
+    @Deprecated protected void setupDialog(Component content, String[] buttonIcons) {
+        this.setContent(content);
+        this.setButtonIcons(buttonIcons);
+        this.setupDialog();
+    }
+    protected void setupDialog() {
         setupEscListener();
 …
             button = new JButton(action);
             if(buttonIcons != null && buttonIcons[i] != null) {
                 button.setIcon(ImageProvider.get(buttonIcons[i]));
+            if(bIcons != null && bIcons[i] != null) {
+                button.setIcon(ImageProvider.get(bIcons[i]));
+            }
 …
         JPanel cp = new JPanel(new GridBagLayout());
         cp.add(content, contentConstraints);
+        if(toggleable) {
+            toggleCheckbox = new JCheckBox(toggleCheckboxText);
+            boolean showDialog = Main.pref.getBoolean("message."+ togglePref, true);
+            toggleCheckbox.setSelected(!showDialog);
+            cp.add(toggleCheckbox, GBC.eol().anchor(GBC.LINE_START).insets(5,5,5,5));
+        }
         cp.add(buttonsPanel, GBC.eol().anchor(GBC.CENTER).insets(5,5,5,5));
+        JScrollPane pane = new JScrollPane(cp);
+        pane.setBorder(null);
+        setContentPane(pane);
+        if (placeContentInScrollPane) {
+            JScrollPane pane = new JScrollPane(cp);
+            pane.setBorder(null);
+            setContentPane(pane);
+        } else {
+            setContentPane(cp);
+        }
         pack();
 …
         setSize(d);
         setLocationRelativeTo(parent);
+    }
-    /**
-     * @return int The selected button. The count starts with 1.
-     *             A return value of 0 means the dialog has been closed otherwise.
-     */
-    public int getValue() {
-        return result;
+    }
 …
                 // We need to set it to zero again, in case the dialog has been re-used
                 // and the result differs from its default value
                 result = 0;
+                result = ExtendedDialog.DialogClosedOtherwise;
                 setVisible(false);
+            }
 …
         super.setVisible(visible);
         if (visible) {
+            toFront();
+        }
+            repaint();
+        }
+    }
+    /**
+     * Calling this will offer the user a "Do not show again" checkbox for the
+     * dialog. Default is to not offer the choice; the dialog will be shown
+     * every time. If the dialog is not shown due to the previous choice of the
+     * user, the result <code>ExtendedDialog.DialogNotShown</code> is returned
+     * @param togglePref  The preference to save the checkbox state to
+     */
+    public void toggleEnable(String togglePref) {
+        this.toggleable = true;
+        this.togglePref = togglePref;
+    }
+    /**
+     * Call this if you "accidentally" called toggleEnable. This doesn't need
+     * to be called for every dialog, as it's the default anyway.
+     */
+    public void toggleDisable() {
+        this.toggleable = false;
+    }
+    /**
+     * Overwrites the default "Don't show again" text of the toggle checkbox
+     * if you want to give more information. Only has an effect if
+     * <code>toggleEnable</code> is set.
+     * @param text
+     */
+    public void setToggleCheckboxText(String text) {
+        this.toggleCheckboxText = text;
+    }
+    /**
+     * This function returns true if the dialog has been set to "do not show again"
+     * @return true if dialog should not be shown again
+     */
+    private boolean toggleCheckState(String togglePref) {
+        toggleable = togglePref != null && !togglePref.equals("");
+        // No identifier given, so return false (= show the dialog)
+        if(!toggleable)
+            return false;
+        this.togglePref = togglePref;
+        // The pref is true, if the dialog should be shown.
+        return !(Main.pref.getBoolean("message."+ togglePref, true));
+    }
+    /**
+     * This function checks the state of the "Do not show again" checkbox and
+     * writes the corresponding pref
+     */
+    private void toggleSaveState() {
+        if(!toggleable || toggleCheckbox == null)
+            return;
+        Main.pref.put("message."+ togglePref, !toggleCheckbox.isSelected());
+    }
+    /**
+     * Convenience function that converts a given string into a JMultilineLabel
+     * @param msg
+     * @return JMultilineLabel
+     */
+    private static JMultilineLabel string2label(String msg) {
+        JMultilineLabel lbl = new JMultilineLabel(msg);
+        // Make it not wider than 2/3 of the screen
+        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        lbl.setMaxWidth(Math.round(screenSize.width*2/3));
+        return lbl;
+    }
+}

/trunk/src/org/openstreetmap/josm/gui/FileDrop.java

-              r2024
+              r2060
 import java.io.PrintStream;
 import java.io.Reader;
+import java.util.Arrays;
+import java.util.List;
+import javax.swing.BorderFactory;
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.actions.OpenFileAction;
 …
     /* Constructor for JOSM file drop */
+    public FileDrop(final java.awt.Component c)
+    {   this(
+            null,  // Logging stream
+            c,     // Drop target
+            javax.swing.BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
+            true, // Recursive
+            new FileDrop.Listener()
+            {
+                public void filesDropped( java.io.File[] files )
+                {
+                    OpenFileAction ofa = new OpenFileAction();
+                    for( int i = 0; i < files.length; i++ )
+                    {
+                        ofa.openFile(files[i]);
+                    }   // end for: through each dropped file
+                }   // end filesDropped
+            }); // end FileDrop.Listener
+    public FileDrop(final java.awt.Component c){
+        this(
+                null,  // Logging stream
+                c,     // Drop target
+                BorderFactory.createMatteBorder( 2, 2, 2, 2, defaultBorderColor ), // Drag border
+                true, // Recursive
+                new FileDrop.Listener(){
+                    public void filesDropped( java.io.File[] files ){
+                        // start asynchronous loading of files
+                        OpenFileAction.OpenFileTask task = new OpenFileAction.OpenFileTask(Arrays.asList(files));
+                        Main.worker.submit(task);
+                    }
+                }
+        );
+    }
     /**
 …
                     // Get a useful list
                     java.util.List fileList = (java.util.List)
+                    List fileList = (java.util.List)
                     tr.getTransferData(java.awt.datatransfer.DataFlavor.javaFileListFlavor);
                     // Convert list to array
                     final java.io.File[] files = (File[]) fileList.toArray();;
+                    final File[] files = (File[]) fileList.toArray();
                     // Alert listener to drop.

/trunk/src/org/openstreetmap/josm/gui/MainApplet.java

-              r2024
+              r2060
 import java.awt.event.KeyEvent;
 import java.io.File;
+import java.io.IOException;
 import java.net.URL;
 import java.util.Arrays;
 …
         public UploadPreferencesAction() {
             super(tr("Upload Preferences"), "upload-preferences", tr("Upload the current preferences to the server"),
+            Shortcut.registerShortcut("applet:uploadprefs", tr("Upload Preferences"), KeyEvent.VK_U, Shortcut.GROUP_HOTKEY), true);
+                    Shortcut.registerShortcut("applet:uploadprefs", tr("Upload Preferences"), KeyEvent.VK_U, Shortcut.GROUP_HOTKEY), true);
+        }
         public void actionPerformed(ActionEvent e) {
 …
         for (String[] s : paramInfo) {
             Collection<String> p = readParameter(s[0], args.get(s[0]));
+            if (p != null)
+            if (p != null) {
                 args.put(s[0], p);
+            }
+        }
         if (!args.containsKey("geometry") && getParameter("width") != null && getParameter("height") != null) {
 …
         Main.pref = new ServerSidePreferences(getCodeBase());
         ((ServerSidePreferences)Main.pref).download(username, password);
         Main.preConstructorInit(args);
         Main.parent = this;
 …
         String param = getParameter(s);
         if (param != null) {
+            if (v == null)
+            if (v == null) {
                 v = new LinkedList<String>();
+            }
             v.addAll(Arrays.asList(param.split(";")));
+        }

/trunk/src/org/openstreetmap/josm/gui/MainApplication.java

-              r2024
+              r2060
         mainFrame.addWindowListener(new WindowAdapter(){
             @Override public void windowClosing(final WindowEvent arg0) {
                 if (Main.breakBecauseUnsavedChanges())
+                if (!Main.saveUnsavedModifications())
                     return;
                 Main.saveGuiGeometry();
 …
         final Map<String, Collection<String>> args = new HashMap<String, Collection<String>>();
         for (String arg : argArray) {
+            if (!arg.startsWith("--"))
+            if (!arg.startsWith("--")) {
                 arg = "--download="+arg;
+            }
             int i = arg.indexOf('=');
             String key = i == -1 ? arg.substring(2) : arg.substring(2,i);
             String value = i == -1 ? "" : arg.substring(i+1);
             Collection<String> v = args.get(key);
+            if (v == null)
+            if (v == null) {
                 v = new LinkedList<String>();
+            }
             v.add(value);
             args.put(key, v);
 …
         // Check if passed as parameter
+        if (args.containsKey("language"))
+        if (args.containsKey("language")) {
             I18n.set((String)(args.get("language").toArray()[0]));
         else
+        } else {
             I18n.set(Main.pref.get("language", null));
+        }
         if (argList.contains("--help") || argList.contains("-?") || argList.contains("-h")) {
 …
         if (((!args.containsKey("no-maximize") && !args.containsKey("geometry")
+        && Main.pref.get("gui.geometry").length() == 0) || args.containsKey("maximize"))
+        && Toolkit.getDefaultToolkit().isFrameStateSupported(JFrame.MAXIMIZED_BOTH))
+                && Main.pref.get("gui.geometry").length() == 0) || args.containsKey("maximize"))
+                && Toolkit.getDefaultToolkit().isFrameStateSupported(JFrame.MAXIMIZED_BOTH)) {
             mainFrame.setExtendedState(JFrame.MAXIMIZED_BOTH);
+        }
         EventQueue.invokeLater(new Runnable() {
 …
     public static void removeObsoletePreferences() {
         String[] obsolete = {
+           "sample.preference.that.does.not.exist", // sample comment, expiry date should go here
+           "osm-server.version", // remove this around 10/2009
+           "osm-server.additional-versions", // remove this around 10/2009
+           null
+                "sample.preference.that.does.not.exist", // sample comment, expiry date should go here
+                "osm-server.version", // remove this around 10/2009
+                "osm-server.additional-versions", // remove this around 10/2009
+                null
         };
         for (String i : obsolete) {
+            if (i == null) continue;
+            if (i == null) {
+                continue;
+            }
             if (Main.pref.hasKey(i)) {
                 Main.pref.removeFromCollection(i, Main.pref.get(i));

/trunk/src/org/openstreetmap/josm/gui/MapStatus.java

-              r2024
+              r2060
                             continue;
+                        }
                         if (osms != null && osms.equals(osmStatus) && ms.modifiers == oldModifiers) {
+                        if (osms.equals(osmStatus) && ms.modifiers == oldModifiers) {
                             continue;
+                        }
 …
                             final StringBuilder text = new StringBuilder();
                             String name = osm.getDisplayName(DefaultNameFormatter.getInstance());
                             if (osm.id == 0 || osm.modified) {
+                            if (osm.getId() == 0 || osm.isModified()) {
                                 name = "<i><b>"+ osm.getDisplayName(DefaultNameFormatter.getInstance())+"*</b></i>";
+                            }
                             text.append(name);
                             if (osm.id != 0) {
                                 text.append("<br>id="+osm.id);
+                            if (osm.getId() != 0) {
+                                text.append("<br>id="+osm.getId());
+                            }
                             for (Entry<String, String> e : osm.entrySet()) {

/trunk/src/org/openstreetmap/josm/gui/MapView.java

-              r2024
+              r2060
 import org.openstreetmap.josm.gui.layer.MapViewPaintable;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
-import org.openstreetmap.josm.gui.layer.OsmDataLayer.ModifiedChangedListener;
 import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer;
 import org.openstreetmap.josm.gui.layer.markerlayer.PlayHeadMarker;
 …
      */
     public void addLayer(Layer layer) {
-        if (layer instanceof OsmDataLayer) {
-            OsmDataLayer editLayer = (OsmDataLayer)layer;
-            editLayer.listenerModified.add(new ModifiedChangedListener(){
-                public void modifiedChanged(boolean value, OsmDataLayer source) {
-                    JOptionPane.getFrameForComponent(Main.parent).setTitle((value?"*":"")
-                            +tr("Java OpenStreetMap Editor"));
+                }
-            });
+        }
         if (layer instanceof MarkerLayer && playHeadMarker == null) {
             playHeadMarker = PlayHeadMarker.create();
 …
+            }
+        }
+        if (layer instanceof OsmDataLayer) {
+            refreshTitle((OsmDataLayer)layer);
+        }
         /* This only makes the buttons look disabled. Disabling the actions as well requires
 …
         if (evt.getPropertyName().equals(Layer.VISIBLE_PROP)) {
             repaint();
+        } else if (evt.getPropertyName().equals(OsmDataLayer.REQUIRES_SAVE_TO_DISK_PROP)
+                || evt.getPropertyName().equals(OsmDataLayer.REQUIRES_UPLOAD_TO_SERVER_PROP)) {
+            OsmDataLayer layer = (OsmDataLayer)evt.getSource();
+            if (layer == getEditLayer()) {
+                refreshTitle(layer);
+            }
+        }
+    }
+    protected void refreshTitle(OsmDataLayer layer) {
+        boolean dirty = layer.requiresSaveToFile() || layer.requiresUploadToServer();
+        if (dirty) {
+            JOptionPane.getFrameForComponent(Main.parent).setTitle("* " + tr("Java OpenStreetMap Editor"));
+        } else {
+            JOptionPane.getFrameForComponent(Main.parent).setTitle(tr("Java OpenStreetMap Editor"));
+        }
+    }

/trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

-              r2024
+              r2060
         double dist = getDist100Pixel();
         return dist >= 2000 ? Math.round(dist/100)/10 +" km" : (dist >= 1
+        ? Math.round(dist*10)/10 +" m" : "< 1 m");
+                ? Math.round(dist*10)/10 +" m" : "< 1 m");
+    }
 …
                         center.east() - getWidth()/2.0*scale,
                         center.north() - getHeight()/2.0*scale),
+                new EastNorth(
+                        center.east() + getWidth()/2.0*scale,
+                        center.north() + getHeight()/2.0*scale));
+                        new EastNorth(
+                                center.east() + getWidth()/2.0*scale,
+                                center.north() + getHeight()/2.0*scale));
     };
 …
         Bounds b = getProjection().getWorldBoundsLatLon();
         return new ProjectionBounds(getProjection().latlon2eastNorth(b.min),
+            getProjection().latlon2eastNorth(b.max));
+                getProjection().latlon2eastNorth(b.max));
     };
 …
                         center.east() - getWidth()/2.0*scale,
                         center.north() - getHeight()/2.0*scale)),
+                getProjection().eastNorth2latlon(new EastNorth(
+                        center.east() + getWidth()/2.0*scale,
+                        center.north() + getHeight()/2.0*scale)));
+                        getProjection().eastNorth2latlon(new EastNorth(
+                                center.east() + getWidth()/2.0*scale,
+                                center.north() + getHeight()/2.0*scale)));
     };
 …
         if(lon < b.min.lon()) {changed = true; lon = b.min.lon(); }
         else if(lon > b.max.lon()) {changed = true; lon = b.max.lon(); }
+        if(changed)
+          newCenter = new CachedLatLon(lat, lon).getEastNorth();
+        if(changed) {
+            newCenter = new CachedLatLon(lat, lon).getEastNorth();
+        }
         if (!newCenter.equals(center)) {
             EastNorth oldCenter = center;
 …
             e2 = getProjection().latlon2eastNorth(new LatLon(lat, b.max.lon()));
             d = e2.east() - e1.east();
+            if(d < width*newScale)
+            if(d < width*newScale) {
                 newScale = Math.max(newScaleH, d/width);
+            }
+        }
         else
+        {
             d = d/(l1.greatCircleDistance(l2)*height*10);
+            if(newScale < d)
+            if(newScale < d) {
                 newScale = d;
+            }
+        }
         if (scale != newScale) {
 …
             return null;
         for (Node n : ds.nodes) {
             if (n.deleted || n.incomplete) {
+            if (n.isDeleted() || n.incomplete) {
                 continue;
+            }
 …
             // when multiple nodes on one point, prefer new or selected nodes
             else if(dist == minDistanceSq && minPrimitive != null
                     && ((n.id == 0 && n.isSelected())
                             || (!minPrimitive.isSelected() && (n.isSelected() || n.id == 0)))) {
+                    && ((n.getId() == 0 && n.isSelected())
+                            || (!minPrimitive.isSelected() && (n.isSelected() || n.getId() == 0)))) {
                 minPrimitive = n;
+            }
 …
             return null;
         for (Way w : ds.ways) {
             if (w.deleted || w.incomplete) {
+            if (w.isDeleted() || w.incomplete) {
                 continue;
+            }
 …
             for (Node n : w.getNodes()) {
                 i++;
                 if (n.deleted || n.incomplete) {
+                if (n.isDeleted() || n.incomplete) {
                     continue;
+                }
 …
             return null;
         for (Way w : ds.ways) {
             if (w.deleted || w.incomplete) {
+            if (w.isDeleted() || w.incomplete) {
                 continue;
+            }
             Node lastN = null;
             for (Node n : w.getNodes()) {
                 if (n.deleted || n.incomplete) {
+                if (n.isDeleted() || n.incomplete) {
                     continue;
+                }
 …
+        }
         for (Node n : ds.nodes) {
             if (!n.deleted && !n.incomplete
+            if (!n.isDeleted() && !n.incomplete
                     && getPoint(n).distanceSq(p) < snapDistance) {
                 nearest.add(n);
 …
             return null;
         for (Node n : ds.nodes) {
             if (!n.deleted && !n.incomplete
+            if (!n.isDeleted() && !n.incomplete
                     && getPoint(n).distanceSq(p) < snapDistance) {
                 nearest.add(n);

/trunk/src/org/openstreetmap/josm/gui/PleaseWaitDialog.java

-              r2024
+              r2060
         setSize(Main.pref.getInteger("progressdialog.size", 600), 120);
+    }
-    @Override
-    public void setVisible(boolean visible) {
-        super.setVisible(visible);
-        if (visible) {
-            // make sure this dialog is always on top of the main JOSM window
-            // and all the other windows (relation editors, detached dialogs, etc.)
-            //
-            toFront();
+        }
+    }
+}

/trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

-              r2024
+              r2060
      */
     public PleaseWaitRunnable(String title, boolean ignoreException) {
+        this(title, new PleaseWaitProgressMonitor(), ignoreException);
+        this(title, new PleaseWaitProgressMonitor(title), ignoreException);
+    }
     public PleaseWaitRunnable(String title, ProgressMonitor progressMonitor, boolean ignoreException) {
         this.title = title;
+        this.progressMonitor = progressMonitor == null?new PleaseWaitProgressMonitor():progressMonitor;
+        this.progressMonitor = progressMonitor == null?new PleaseWaitProgressMonitor(title):progressMonitor;
         this.ignoreException = ignoreException;
         this.progressMonitor.addCancelListener(this);

/trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

-              r2024
+              r2060
             // nodes
             for (Node n : nc.getCurrentDataSet().nodes) {
                 if (!n.deleted && !n.incomplete && r.contains(nc.getPoint(n))) {
+                if (!n.isDeleted() && !n.incomplete && r.contains(nc.getPoint(n))) {
                     selection.add(n);
+                }
 …
             // ways
             for (Way w : nc.getCurrentDataSet().ways) {
                 if (w.deleted || w.getNodesCount() == 0 || w.incomplete) {
+                if (w.isDeleted() || w.getNodesCount() == 0 || w.incomplete) {
                     continue;
+                }

/trunk/src/org/openstreetmap/josm/gui/conflict/pair/ListMergeModel.java

r2024	r2060
56	56	*/
57	57	public abstract class ListMergeModel<T> extends Observable {
58		private static final Logger logger = Logger.getLogger(ListMergeModel.class.getName());
	58	//private static final Logger logger = Logger.getLogger(ListMergeModel.class.getName());
59	59
60	60	public static final String FROZEN_PROP = ListMergeModel.class.getName() + ".frozen";

/trunk/src/org/openstreetmap/josm/gui/conflict/pair/ListMerger.java

r2024	r2060
45	45	*/
46	46	public abstract class ListMerger<T> extends JPanel implements PropertyChangeListener, Observer {
47		private static final Logger logger = Logger.getLogger(ListMerger.class.getName());
	47	//private static final Logger logger = Logger.getLogger(ListMerger.class.getName());
48	48
49	49	protected JTable myEntriesTable;

/trunk/src/org/openstreetmap/josm/gui/conflict/pair/nodes/NodeListTableCellRenderer.java

-              r2024
+              r2060
  */
 public  class NodeListTableCellRenderer extends JLabel implements TableCellRenderer {
+    static private final Logger logger = Logger.getLogger(NodeListTableCellRenderer.class.getName());
+    private static DecimalFormat COORD_FORMATTER = new DecimalFormat("###0.0000");
+    //static private final Logger logger = Logger.getLogger(NodeListTableCellRenderer.class.getName());
+    //private static DecimalFormat COORD_FORMATTER = new DecimalFormat("###0.0000");
     public final static Color BGCOLOR_SELECTED = new Color(143,170,255);
     public final static Color BGCOLOR_EMPTY_ROW = new Color(234,234,234);
 …
         //
         sb.append("<strong>id</strong>=")
         .append(primitive.id)
+        .append(primitive.getId())
         .append("<br>");
 …
         reset();
         switch(column) {
+        case 0:
+            renderRowId(getModel(table),row, isSelected);
+            break;
+        case 1:
+            if (node == null) {
+                renderEmptyRow();
+            } else {
+                renderNode(getModel(table), node, row, isSelected);
+            }
+            break;
+        default:
+            // should not happen
+            throw new RuntimeException(tr("unexpected column index. Got {0}", column));
+            case 0:
+                renderRowId(getModel(table),row, isSelected);
+                break;
+            case 1:
+                if (node == null) {
+                    renderEmptyRow();
+                } else {
+                    renderNode(getModel(table), node, row, isSelected);
+                }
+                break;
+            default:
+                // should not happen
+                throw new RuntimeException(tr("unexpected column index. Got {0}", column));
+        }
         return this;

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

-              r2024
+              r2060
 import org.openstreetmap.josm.gui.MapView;
 import org.openstreetmap.josm.gui.SideButton;
+import org.openstreetmap.josm.gui.io.SaveLayersDialog;
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 …
  */
 public class LayerListDialog extends ToggleDialog {
+    static private final Logger logger = Logger.getLogger(LayerListDialog.class.getName());
+    //static private final Logger logger = Logger.getLogger(LayerListDialog.class.getName());
     /** the unique instance of the dialog */
 …
+        }
+        protected boolean confirmSkipSaving(OsmDataLayer layer) {
+            int result = new ExtendedDialog(Main.parent,
+                    tr("Unsaved Changes"),
+                    tr("There are unsaved changes in the layer''{0}''. Delete the layer anwyay?",layer.getName()),
+                    new String[] {tr("Delete Layer"), tr("Cancel")},
+                    new String[] {"dialogs/delete.png", "cancel.png"}).getValue();
+            return result == 1;
+        }
+        protected boolean confirmDeleteLayer(Layer layer) {
+            return ConditionalOptionPaneUtil.showConfirmationDialog(
+                    "delete_layer",
+                    Main.parent,
+                    tr("Do you really want to delete layer ''{0}''?", layer.getName()),
+                    tr("Confirmation"),
+                    JOptionPane.YES_NO_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    JOptionPane.YES_OPTION);
+        }
+        protected DeleteDecision confirmDeleteMultipleLayer(Layer layer, int idx, int numLayers) {
+            String options[] = new String[] {
+                    tr("Yes"),
+                    tr("No"),
+                    tr("Delete all"),
+                    tr("Cancel")
+            };
+            int ret = ConditionalOptionPaneUtil.showOptionDialog(
+                    "delete_layer",
+                    Main.parent,
+                    tr("Do you really want to delete layer ''{0}''?", layer.getName()),
+                    tr("Deleting layer {0} of {1}", idx+1, numLayers),
+                    JOptionPane.DEFAULT_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    options,
+                    options[0]
+            );
+            switch(ret) {
+                case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return DeleteDecision.deleteAll;
+                case JOptionPane.CLOSED_OPTION: return DeleteDecision.cancel;
+                case 0: return DeleteDecision.deleteCurrent;
+                case 1: return DeleteDecision.dontDeleteCurrent;
+                case 2: return DeleteDecision.deleteAll;
+                case 3: return DeleteDecision.cancel;
+                default:
+                    // shouldn't happen. This is the safest option.
+                    return DeleteDecision.cancel;
+            }
+        }
+        public void deleteSingleLayer(Layer layer) {
+            if (layer == null)
+        protected boolean enforceUploadOrSaveModifiedData(List<Layer> selectedLayers) {
+            SaveLayersDialog dialog = new SaveLayersDialog(Main.parent);
+            List<OsmDataLayer> layersWithUnmodifiedChanges = new ArrayList<OsmDataLayer>();
+            for (Layer l: selectedLayers) {
+                if (! (l instanceof OsmDataLayer)) {
+                    continue;
+                }
+                OsmDataLayer odl = (OsmDataLayer)l;
+                if (odl.requiresSaveToFile() || odl.requiresUploadToServer()) {
+                    layersWithUnmodifiedChanges.add(odl);
+                }
+            }
+            dialog.prepareForSavingAndUpdatingLayersBeforeDelete();
+            if (!layersWithUnmodifiedChanges.isEmpty()) {
+                dialog.getModel().populate(layersWithUnmodifiedChanges);
+                dialog.setVisible(true);
+                switch(dialog.getUserAction()) {
+                case CANCEL: return false;
+                case PROCEED: return true;
+                default: return false;
+                }
+            }
+            return true;
+        }
+        public void actionPerformed(ActionEvent e) {
+            List<Layer> selectedLayers;
+            if (this.layer == null) {
+                selectedLayers = getModel().getSelectedLayers();
+            } else {
+                selectedLayers = Collections.singletonList(this.layer);
+            }
+            if (selectedLayers.isEmpty())
                 return;
+            if (layer instanceof OsmDataLayer) {
+                OsmDataLayer dataLayer = (OsmDataLayer)layer;
+                if (dataLayer.isModified()) {
+                    if (! confirmSkipSaving(dataLayer))
+                        return;
+                }
+                else if (!confirmDeleteLayer(dataLayer))
+                    return;
+            } else {
+                if (!confirmDeleteLayer(layer))
+                    return;
+            }
+            // model and view are going to be updated via LayerChangeListener
+            //
+            Main.main.removeLayer(layer);
+        }
+        public void deleteMultipleLayers(List<Layer> layers) {
+            boolean doAskConfirmation = true;
+            for (int i=0; i < layers.size(); i++) {
+                Layer layer = layers.get(i);
+                if (layer instanceof OsmDataLayer) {
+                    OsmDataLayer dataLayer = (OsmDataLayer)layer;
+                    if (dataLayer.isModified() && ! confirmSkipSaving(dataLayer)) {
+                        continue;
+                    }
+                }
+                if (doAskConfirmation) {
+                    DeleteDecision decision = confirmDeleteMultipleLayer(layer, i, layers.size());
+                    switch(decision) {
+                        case deleteCurrent: /* do nothing */ break;
+                        case deleteAll: doAskConfirmation = false; break;
+                        case dontDeleteCurrent: continue;
+                        case cancel: return;
+                    }
+                }
+                // model and view are going to be updated via LayerChangeListener
+                //
+                Main.main.removeLayer(layer);
+            }
+        }
+        public void actionPerformed(ActionEvent e) {
+            if (this.layer == null) {
+                List<Layer> selectedLayers = getModel().getSelectedLayers();
+                if (selectedLayers.isEmpty())
+                    return;
+                if (selectedLayers.size() == 1) {
+                    deleteSingleLayer(selectedLayers.get(0));
+                } else {
+                    deleteMultipleLayers(selectedLayers);
+                }
+            } else {
+                deleteSingleLayer(this.layer);
+            if (! enforceUploadOrSaveModifiedData(selectedLayers))
+                return;
+            for(Layer l: selectedLayers) {
+                Main.main.removeLayer(l);
+            }
+        }

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

-              r2024
+              r2060
     void membershipEdit(int row) {
         Relation relation = (Relation)membershipData.getValueAt(row, 0);
         Main.main.map.relationListDialog.selectRelation(relation);
+        Main.map.relationListDialog.selectRelation(relation);
         RelationEditor.getEditor(
                 Main.map.mapView.getEditLayer(),
 …
                             c.setFont(c.getFont().deriveFont(Font.ITALIC));
                         } else {
                             final Map.Entry entry = (Map.Entry) v.entrySet().iterator().next();
+                            final Map.Entry entry = (Map.Entry) v.entrySet().iterator().next();
                             str = (String) entry.getKey();
+                        }
 …
+        }
-        LinkedList<TaggingPreset> p = new LinkedList<TaggingPreset>();
         presets.removeAll();
         int total = nodes+ways+relations+closedways;
 …
         if (Main.main.getCurrentDataSet() != null) {
             for (Relation r : Main.main.getCurrentDataSet().relations) {
                 if (!r.deleted && !r.incomplete) {
+                if (!r.isDeleted() && !r.incomplete) {
                     for (RelationMember m : r.getMembers()) {
                         if (newSelection.contains(m.getMember())) {
 …
         protected void deleteFromRelation(int row) {
             Relation cur = (Relation)membershipData.getValueAt(row, 0);
+            int result = new ExtendedDialog(Main.parent,
+            ExtendedDialog ed = new ExtendedDialog(Main.parent,
                     tr("Change relation"),
+                    tr("Really delete selection from relation {0}?", cur.getDisplayName(DefaultNameFormatter.getInstance())),
+                    new String[] {tr("Delete from relation"), tr("Cancel")},
+                    new String[] {"dialogs/delete.png", "cancel.png"}).getValue();
+            if(result != 1)
+                    new String[] {tr("Delete from relation"), tr("Cancel")});
+            ed.setButtonIcons(new String[] {"dialogs/delete.png", "cancel.png"});
+            ed.setContent(tr("Really delete selection from relation {0}?", cur.getDisplayName(DefaultNameFormatter.getInstance())));
+            ed.showDialog();
+            if(ed.getValue() != 1)
                 return;
             Relation rel = new Relation(cur);
             Collection<OsmPrimitive> sel = Main.main.getCurrentDataSet().getSelected();
+            int index = 0;
+            for (RelationMember rm : cur.getMembers()) {
+                for (OsmPrimitive osm : sel) {
+                    if (rm.getMember() == osm)
+                    {
+                        rel.removeMember(index);
+                        break;
+                    }
+                }
+                index++;
+            for (OsmPrimitive primitive: sel) {
+                rel.removeMembersFor(primitive);
+            }
             Main.main.undoRedo.add(new ChangeCommand(cur, rel));

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

-              r2024
+              r2060
             int i = 0;
             for (OsmPrimitive e : DataSet.sort(Main.main.getCurrentDataSet().relations)) {
                 if (!e.deleted && !e.incomplete) {
+                if (!e.isDeleted() && !e.incomplete) {
                     list.setElementAt(e, i++);
+                }
 …
             Relation copy = new Relation();
             copy.cloneFrom(original);
+            // FIXME: id is going to be hidden. How to reset a primitive?
+            //
             copy.id = 0;
             copy.modified = true;
+            copy.setModified(true);
             RelationEditor editor = RelationEditor.getEditor(
                     Main.main.getEditLayer(),

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

-              r2024
+              r2060
 import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trn;
 import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.util.Arrays;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.text.NumberFormat;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.swing.AbstractAction;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
 import javax.swing.ListSelectionModel;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
 import javax.swing.table.DefaultTableModel;
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.AbstractInfoAction;
 import org.openstreetmap.josm.data.SelectionChangedListener;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.User;
+import org.openstreetmap.josm.gui.SideButton;
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
+import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.Shortcut;
 …
  * selection area, along with the number of objects.
+ *
- * @author Frederik Ramm <frederik@remote.org>
  */
 public class UserListDialog extends ToggleDialog implements SelectionChangedListener, MouseListener, LayerChangeListener {
+public class UserListDialog extends ToggleDialog implements SelectionChangedListener, LayerChangeListener {
     /**
      * The display list.
      */
+    private final DefaultTableModel data = new DefaultTableModel() {
+        @Override public boolean isCellEditable(int row, int column) {
+            return false;
+        }
+        @Override public Class<?> getColumnClass(int columnIndex) {
+            return columnIndex == 0 ? String.class : Integer.class;
+        }
+    };
+    private JTable userTable = new JTable(data);
+    private static User anonymousUser = User.get("(anonymous users)");
+    private JTable userTable;
+    private UserTableModel model;
+    private SelectUsersPrimitivesAction selectionUsersPrimitivesAction;
+    private ShowUserInfoAction showUserInfoAction;
     public UserListDialog() {
 …
                 Shortcut.registerShortcut("subwindow:authors", tr("Toggle: {0}", tr("Authors")), KeyEvent.VK_A, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 150);
+        data.setColumnIdentifiers(new String[]{tr("Author"),tr("# Objects"),"%"});
+        userTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        add(new JScrollPane(userTable), BorderLayout.CENTER);
+        if (Main.main.getCurrentDataSet() != null) {
+            selectionChanged(Main.main.getCurrentDataSet().getSelected());
+        }
+        userTable.addMouseListener(this);
+        build();
         DataSet.selListeners.add(this);
         Layer.listeners.add(this);
+    }
+    @Override public void setVisible(boolean b) {
+        super.setVisible(b);
+        if (b && Main.main.getCurrentDataSet() != null) {
+            selectionChanged(Main.main.getCurrentDataSet().getSelected());
+        }
+    protected JPanel buildButtonRow() {
+        JPanel pnl = new JPanel();
+        pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
+        // -- select users primitives action
+        //
+        selectionUsersPrimitivesAction = new SelectUsersPrimitivesAction();
+        userTable.getSelectionModel().addListSelectionListener(selectionUsersPrimitivesAction);
+        pnl.add(new SideButton(selectionUsersPrimitivesAction));
+        // -- info action
+        //
+        showUserInfoAction = new ShowUserInfoAction();
+        userTable.getSelectionModel().addListSelectionListener(showUserInfoAction);
+        pnl.add(new SideButton(showUserInfoAction));
+        return pnl;
+    }
+    protected void build() {
+        JPanel pnl = new JPanel();
+        pnl.setLayout(new BorderLayout());
+        model = new UserTableModel();
+        userTable = new JTable(model);
+        userTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+        pnl.add(new JScrollPane(userTable), BorderLayout.CENTER);
+        // -- the button row
+        pnl.add(buildButtonRow(), BorderLayout.SOUTH);
+        userTable.addMouseListener(new DoubleClickAdapter());
+        add(pnl, BorderLayout.CENTER);
+    }
 …
      */
     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
+        if (!isVisible())
+            return;
+        class UserCount {
+            User user;
+            int count;
+            UserCount(User user, int count) { this.user=user; this.count=count; }
+        }
+        if (data == null)
+            return; // selection changed may be received in base class constructor before init
+        data.setRowCount(0);
+        HashMap<User,UserCount> counters = new HashMap<User,UserCount>();
+        int all = 0;
+        for (OsmPrimitive p : newSelection) {
+            User u = p.user;
+            if (u == null) {
+                u = anonymousUser;
+            }
+            UserCount uc = counters.get(u);
+            if (uc == null) {
+                counters.put(u, uc = new UserCount(u, 0));
+            }
+            uc.count++;
+            all++;
+        }
+        UserCount[] ucArr = new UserCount[counters.size()];
+        counters.values().toArray(ucArr);
+        Arrays.sort(ucArr, new Comparator<UserCount>() {
+            public int compare(UserCount a, UserCount b) {
+                return (a.count<b.count) ? 1 : (a.count>b.count) ? -1 : 0;
+            }
+        });
+        for (UserCount uc : ucArr) {
+            data.addRow(new Object[] { uc.user.name, uc.count, uc.count * 100 / all });
+        }
+        if(ucArr.length != 0) {
+            setTitle(tr("Authors: {0}", ucArr.length));
+        refresh(newSelection);
+    }
+    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
+        if (newLayer instanceof OsmDataLayer) {
+            refresh(((OsmDataLayer) newLayer).data.getSelected());
+        } else {
+            refresh(null);
+        }
+    }
+    public void layerAdded(Layer newLayer) {
+        // do nothing
+    }
+    public void layerRemoved(Layer oldLayer) {
+        // do nothing
+    }
+    public void refresh(Collection<? extends OsmPrimitive> fromPrimitives) {
+        model.populate(fromPrimitives);
+        if(model.getRowCount() != 0) {
+            setTitle(trn("{0} Author", "{0} Authors", model.getRowCount() , model.getRowCount()));
         } else {
             setTitle(tr("Authors"));
 …
+    }
+    public void mouseClicked(MouseEvent e) {
+        if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount()==2) {
+            int index = userTable.getSelectedRow();
+            String userName = (String) data.getValueAt(index, 0);
+            if (userName==null)
+                return;
+    class SelectUsersPrimitivesAction extends AbstractAction implements ListSelectionListener{
+        public SelectUsersPrimitivesAction() {
+            putValue(NAME, tr("Select"));
+            putValue(SHORT_DESCRIPTION, tr("Select primitives submitted by this user"));
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "select"));
+            updateEnabledState();
+        }
+        public void select() {
+            int indexes[] = userTable.getSelectedRows();
+            if (indexes == null || indexes.length == 0) return;
+            model.selectPrimitivesOwnedBy(userTable.getSelectedRows());
+        }
+        public void actionPerformed(ActionEvent e) {
+            select();
+        }
+        protected void updateEnabledState() {
+            setEnabled(userTable != null && userTable.getSelectedRowCount() > 0);
+        }
+        public void valueChanged(ListSelectionEvent e) {
+            updateEnabledState();
+        }
+    }
+    /**
+     * Action for launching the info page of a user
+     */
+    class ShowUserInfoAction extends AbstractInfoAction implements ListSelectionListener {
+        public ShowUserInfoAction() {
+            putValue(NAME, tr("Show info"));
+            putValue(SHORT_DESCRIPTION, tr("Launches a browser with information about the user"));
+            putValue(SMALL_ICON, ImageProvider.get("about"));
+            updateEnabledState();
+        }
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            int rows[] = userTable.getSelectedRows();
+            if (rows == null || rows.length == 0) return;
+            List<User> users = model.getSelectedUsers(rows);
+            if (users.isEmpty()) return;
+            if (users.size() > 10) {
+                System.out.println(tr("Warning: only launching info browsers for the first {0} of {1} selected users", 10, users.size()));
+            }
+            int num = Math.min(10, users.size());
+            Iterator<User> it = users.iterator();
+            while(it.hasNext() && num > 0) {
+                String url = createInfoUrl(it.next());
+                if (url == null) {
+                    break;
+                }
+                launchBrowser(url);
+                num--;
+            }
+        }
+        @Override
+        protected String createInfoUrl(Object infoObject) {
+            User user = (User)infoObject;
+            try {
+                return getBaseUserUrl() + "/" + URLEncoder.encode(user.name, "UTF-8");
+            } catch(UnsupportedEncodingException e) {
+                e.printStackTrace();
+                JOptionPane.showMessageDialog(
+                        Main.parent,
+                        tr("<html>Failed to create an URL because the encoding ''{0}'' was<br>"
+                                + "was missing on this system.</html>", "UTF-8"),
+                                tr("Missing encoding"),
+                                JOptionPane.ERROR_MESSAGE
+                );
+                return null;
+            }
+        }
+        @Override
+        protected void updateEnabledState() {
+            setEnabled(userTable != null && userTable.getSelectedRowCount() > 0);
+        }
+        public void valueChanged(ListSelectionEvent e) {
+            updateEnabledState();
+        }
+    }
+    class DoubleClickAdapter extends MouseAdapter {
+        @Override
+        public void mouseClicked(MouseEvent e) {
+            if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount()==2) {
+                selectionUsersPrimitivesAction.select();
+            }
+        }
+    }
+    /**
+     * Action for selecting the primitives contributed by the currently selected
+     * users.
+     *
+     */
+    private static class UserInfo implements Comparable<UserInfo> {
+        public User user;
+        public int count;
+        public double percent;
+        UserInfo(User user, int count, double percent) {
+            this.user=user;
+            this.count=count;
+            this.percent = percent;
+        }
+        public int compareTo(UserInfo o) {
+            if (count < o.count) return 1;
+            if (count > o.count) return -1;
+            if (user== null || user.name == null) return 1;
+            if (o.user == null || o.user.name == null) return -1;
+            return user.name.compareTo(o.user.name);
+        }
+        public String getName() {
+            if (user == null) return null;
+            return user.name;
+        }
+    }
+    /**
+     * The table model for the users
+     *
+     */
+    class UserTableModel extends DefaultTableModel {
+        private ArrayList<UserInfo> data;
+        public UserTableModel() {
+            setColumnIdentifiers(new String[]{tr("Author"),tr("# Objects"),"%"});
+            data = new ArrayList<UserInfo>();
+        }
+        protected Map<User, Integer> computeStatistics(Collection<? extends OsmPrimitive> primitives) {
+            HashMap<User, Integer> ret = new HashMap<User, Integer>();
+            if (primitives == null || primitives.isEmpty()) return ret;
+            for (OsmPrimitive primitive: primitives) {
+                if (primitive.user == null) {
+                    continue;
+                }
+                if (ret.containsKey(primitive.user)) {
+                    ret.put(primitive.user, ret.get(primitive.user) + 1);
+                } else {
+                    ret.put(primitive.user, 1);
+                }
+            }
+            return ret;
+        }
+        public void populate(Collection<? extends OsmPrimitive> primitives) {
+            Map<User,Integer> statistics = computeStatistics(primitives);
+            data.clear();
+            if (primitives != null) {
+                for (Map.Entry<User, Integer> entry: statistics.entrySet()) {
+                    data.add(new UserInfo(entry.getKey(), entry.getValue(), (double)entry.getValue() /  (double)primitives.size()));
+                }
+            }
+            Collections.sort(data);
+            fireTableDataChanged();
+        }
+        @Override
+        public int getRowCount() {
+            if (data == null) return 0;
+            return data.size();
+        }
+        @Override
+        public Object getValueAt(int row, int column) {
+            UserInfo info = data.get(row);
+            switch(column) {
+                case 0: /* author */ return info.getName() == null ? "" : info.getName();
+                case 1: /* count */ return info.count;
+                case 2: /* percent */ return NumberFormat.getPercentInstance().format(info.percent);
+            }
+            return null;
+        }
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            return false;
+        }
+        public void selectPrimitivesOwnedBy(int [] rows) {
+            Set<User> users= new HashSet<User>();
+            for (int index: rows) {
+                if (data.get(index).user == null) {
+                    continue;
+                }
+                users.add(data.get(index).user);
+            }
             Collection<OsmPrimitive> selected = Main.main.getCurrentDataSet().getSelected();
             Collection<OsmPrimitive> byUser = new LinkedList<OsmPrimitive>();
             for (OsmPrimitive p : selected) {
+                if (p.user!= null && userName.equals(p.user.name)) {
+                if (p.user == null) {
+                    continue;
+                }
+                if (users.contains(p.user)) {
                     byUser.add(p);
+                }
 …
             Main.main.getCurrentDataSet().setSelected(byUser);
+        }
+    }
+    public void mouseEntered(MouseEvent e) {
+    }
+    public void mouseExited(MouseEvent e) {
+    }
+    public void mousePressed(MouseEvent e) {
+    }
+    public void mouseReleased(MouseEvent e) {
+    }
+    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
+        if (newLayer instanceof OsmDataLayer) {
+            OsmDataLayer dataLayer = (OsmDataLayer)newLayer;
+            selectionChanged(dataLayer.data.getSelected());
+        }
+    }
+    public void layerAdded(Layer newLayer) {
+        // do nothing
+    }
+    public void layerRemoved(Layer oldLayer) {
+        // do nothing
+        public List<User> getSelectedUsers(int rows[]) {
+            LinkedList<User> ret = new LinkedList<User>();
+            if (rows == null || rows.length == 0) return ret;
+            for (int row: rows) {
+                if (data.get(row).user == null) {
+                    continue;
+                }
+                ret.add(data.get(row).user);
+            }
+            return ret;
+        }
+    }
+}

/trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

-              r2024
+              r2060
 import java.awt.Insets;
 import java.awt.event.ActionEvent;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
 import java.awt.event.FocusAdapter;
 import java.awt.event.FocusEvent;
 …
 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.gui.SideButton;
-import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionCache;
-import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionList;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.gui.tagging.AutoCompletingTextField;
+import org.openstreetmap.josm.gui.tagging.TagCellEditor;
+import org.openstreetmap.josm.gui.tagging.TagEditorModel;
+import org.openstreetmap.josm.gui.tagging.TagTable;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
 import org.openstreetmap.josm.io.OsmApi;
 import org.openstreetmap.josm.io.OsmServerObjectReader;
 …
         //
         acCache = AutoCompletionCache.getCacheForLayer(getLayer());
         acCache.initFromJOSMDataset();
+        acCache.initFromDataSet();
         acList = new AutoCompletionList();
 …
         final JScrollPane scrollPane = new JScrollPane(tagTable);
-        // this adapters ensures that the width of the tag table columns is adjusted
-        // to the width of the scroll pane viewport. Also tried to overwrite
-        // getPreferredViewportSize() in JTable, but did not work.
-        //
-        scrollPane.addComponentListener(new ComponentAdapter() {
-            @Override
-            public void componentResized(ComponentEvent e) {
-                super.componentResized(e);
-                Dimension d = scrollPane.getViewport().getExtentSize();
-                tagTable.adjustColumnWidth(d.width);
+            }
-        });
         GridBagConstraints gc = new GridBagConstraints();
         gc.gridx = 0;
 …
         final JScrollPane scrollPane = new JScrollPane(memberTable);
-        // this adapters ensures that the width of the tag table columns is adjusted
-        // to the width of the scroll pane viewport. Also tried to overwrite
-        // getPreferredViewportSize() in JTable, but did not work.
-        //
-        scrollPane.addComponentListener(new ComponentAdapter() {
-            @Override
-            public void componentResized(ComponentEvent e) {
-                super.componentResized(e);
-                Dimension d = scrollPane.getViewport().getExtentSize();
-                memberTable.adjustColumnWidth(d.width);
+            }
-        });
         GridBagConstraints gc = new GridBagConstraints();
 …
         protected void updateEnabledState() {
             setEnabled(getRelation() != null && getRelation().id > 0);
+            setEnabled(getRelation() != null && getRelation().getId() > 0);
+        }
+    }
 …
             try {
                 progressMonitor.indeterminateSubTask("");
                 OsmServerObjectReader reader = new OsmServerObjectReader(getRelation().id, OsmPrimitiveType.RELATION,
+                OsmServerObjectReader reader = new OsmServerObjectReader(getRelation().getId(), OsmPrimitiveType.RELATION,
                         true);
                 DataSet dataSet = reader.parseOsm(progressMonitor

/trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberRoleCellEditor.java

-              r2024
+              r2060
 import javax.swing.table.TableCellEditor;
+import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionCache;
+import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionItemPritority;
+import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionList;
+import org.openstreetmap.josm.gui.dialogs.relation.ac.AutoCompletionListItem;
+import org.openstreetmap.josm.gui.tagging.AutoCompletingTextField;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionListItem;
 public class MemberRoleCellEditor extends AbstractCellEditor implements TableCellEditor {

/trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTable.java

-              r2024
+              r2060
 import static org.openstreetmap.josm.tools.I18n.tr;
+import java.awt.Container;
+import java.awt.Dimension;
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
 …
 import javax.swing.JPopupMenu;
 import javax.swing.JTable;
+import javax.swing.JViewport;
 import javax.swing.KeyStroke;
 import javax.swing.ListSelectionModel;
 …
+    }
+    /**
+     * adjusts the width of the columns for the tag name and the tag value to the width of the
+     * scroll panes viewport.
+     *
+     * Note: {@see #getPreferredScrollableViewportSize()} did not work as expected
+     *
+     * @param scrollPaneWidth the width of the scroll panes viewport
+     */
+    public void adjustColumnWidth(int scrollPaneWidth) {
+        TableColumnModel tcm = getColumnModel();
+        int width = scrollPaneWidth;
+        width = width / 3;
+        if (width > 0) {
+            tcm.getColumn(0).setMinWidth(width);
+            tcm.getColumn(0).setMaxWidth(width);
+            tcm.getColumn(1).setMinWidth(width);
+            tcm.getColumn(1).setMaxWidth(width);
+            tcm.getColumn(2).setMinWidth(width);
+            tcm.getColumn(2).setMaxWidth(width);
+        }
+    @Override
+    public Dimension getPreferredSize(){
+        Container c = getParent();
+        while(c != null && ! (c instanceof JViewport)) {
+            c = c.getParent();
+        }
+        if (c != null) {
+            Dimension d = super.getPreferredSize();
+            d.width = c.getSize().width;
+            return d;
+        }
+        return super.getPreferredSize();
+    }

/trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ReferringRelationsBrowser.java

r2024	r2060
107	107	getLayer(),
108	108	full,
109		new PleaseWaitProgressMonitor()
	109	new PleaseWaitProgressMonitor(tr("Loading parent relations"))
110	110	);
111	111	task.setContinuation(

/trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java

r2024	r2060
296	296	return p.equals(reference);
297	297	}
	298
	299	public HistoryOsmPrimitive getPrimitive(int row) {
	300	return history.get(row);
	301	}
298	302	}
299	303

/trunk/src/org/openstreetmap/josm/gui/history/VersionInfoPanel.java

-              r2024
+              r2060
 import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseEvent;
 import java.text.SimpleDateFormat;
 import java.util.Observable;
 …
 import javax.swing.JPanel;
+import org.openstreetmap.josm.actions.AbstractInfoAction;
 import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
+import org.openstreetmap.josm.tools.ImageProvider;
 /**
 …
         if (primitive == null)
             return "";
+        String url = AbstractInfoAction.getBaseBrowseUrl() + "/changeset/" + primitive.getChangesetId();
         String text = tr(
                 "<html>Version <strong>{0}</strong> created on <strong>{1}</strong> by <strong>{2}</strong></html>",
+                "<html>Version <strong>{0}</strong> created on <strong>{1}</strong> by <strong>{2}</strong> in changeset <strong>{3}</strong>",
                 Long.toString(primitive.getVersion()),
                 new SimpleDateFormat().format(primitive.getTimestamp()),
+                primitive.getUser()
+                primitive.getUser(),
+                primitive.getChangesetId()
         );
         return text;

/trunk/src/org/openstreetmap/josm/gui/history/VersionTable.java

-              r2024
+              r2060
 package org.openstreetmap.josm.gui.history;
+import static org.openstreetmap.josm.tools.I18n.tr;
+import java.awt.event.ActionEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 …
 import javax.swing.DefaultListSelectionModel;
+import javax.swing.JPopupMenu;
 import javax.swing.JTable;
 import javax.swing.ListSelectionModel;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
+import org.openstreetmap.josm.actions.AbstractInfoAction;
+import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
+import org.openstreetmap.josm.tools.ImageProvider;
 /**
 …
     private static Logger logger = Logger.getLogger(VersionTable.class.getName());
+    private VersionTablePopupMenu popupMenu;
     protected void build() {
 …
         addMouseListener(new MouseHandler());
         getSelectionModel().addListSelectionListener(new SelectionHandler());
+        popupMenu = new VersionTablePopupMenu();
+        addMouseListener(new PopupMenuTrigger());
+    }
 …
     protected void handleSelectReferencePointInTime(int row) {
+        getVesionTableModel().setReferencePointInTime(row);
+        getVersionTableModel().setReferencePointInTime(row);
+    }
     protected void handleSelectCurrentPointInTime(int row) {
+        getVesionTableModel().setCurrentPointInTime(row);
+        getVersionTableModel().setCurrentPointInTime(row);
+    }
+    protected HistoryBrowserModel.VersionTableModel getVesionTableModel() {
+    protected HistoryBrowserModel.VersionTableModel getVersionTableModel() {
         return (HistoryBrowserModel.VersionTableModel) getModel();
+    }
 …
         repaint();
+    }
+    protected void showPopupMenu(MouseEvent evt) {
+        HistoryBrowserModel.VersionTableModel model = getVersionTableModel();
+        int row = getSelectedRow();
+        if (row == -1) {
+            row = rowAtPoint(evt.getPoint());
+        }
+        HistoryOsmPrimitive primitive = model.getPrimitive(row);
+        popupMenu.prepare(primitive);
+        popupMenu.show(evt.getComponent(), evt.getX(), evt.getY());
+    }
+    class PopupMenuTrigger extends MouseAdapter {
+        @Override
+        public void mousePressed(MouseEvent e) {
+            showPopup(e);
+        }
+        @Override
+        public void mouseReleased(MouseEvent e) {
+            showPopup(e);
+        }
+        private void showPopup(MouseEvent e) {
+            if (e.isPopupTrigger()) {
+                showPopupMenu(e);
+            }
+        }
+    }
+    class ChangesetInfoAction extends AbstractInfoAction {
+        private HistoryOsmPrimitive primitive;
+        public ChangesetInfoAction() {
+            putValue(NAME, tr("Changeset info"));
+            putValue(SHORT_DESCRIPTION, tr("Launch browser with information about the changeset"));
+            putValue(SMALL_ICON, ImageProvider.get("about"));
+        }
+        @Override
+        protected String createInfoUrl(Object infoObject) {
+            HistoryOsmPrimitive primitive = (HistoryOsmPrimitive) infoObject;
+            return getBaseBrowseUrl() + "/changeset/" + primitive.getChangesetId();
+        }
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            if (!isEnabled())
+                return;
+            String url = createInfoUrl(primitive);
+            launchBrowser(url);
+        }
+        public void prepare(HistoryOsmPrimitive primitive) {
+            putValue(NAME, tr("Show changeset {0}", primitive.getChangesetId()));
+            this.primitive = primitive;
+        }
+    }
+    class VersionTablePopupMenu extends JPopupMenu {
+        private ChangesetInfoAction changesetInfoAction;
+        protected void build() {
+            changesetInfoAction = new ChangesetInfoAction();
+            add(changesetInfoAction);
+        }
+        public VersionTablePopupMenu() {
+            super();
+            build();
+        }
+        public void prepare(HistoryOsmPrimitive primitive) {
+            changesetInfoAction.prepare(primitive);
+            invalidate();
+        }
+    }
+}

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

r2024	r2060
895	895	}
896	896	}
897		new DownloadOsmTaskList().download(false, toDownload, new PleaseWaitProgressMonitor());
	897	new DownloadOsmTaskList().download(false, toDownload, new PleaseWaitProgressMonitor(tr("Download data")));
898	898	}
899	899	}

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

r2024	r2060
45	45
46	46	/** keeps track of property change listeners */
47		pr~~ivate~~ PropertyChangeSupport propertyChangeSupport;
	47	protected PropertyChangeSupport propertyChangeSupport;
48	48
49	49	/**

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

-              r2024
+              r2060
  */
 public class OsmDataLayer extends Layer {
+    static public final String REQUIRES_SAVE_TO_DISK_PROP = OsmDataLayer.class.getName() + ".requiresSaveToDisk";
+    static public final String REQUIRES_UPLOAD_TO_SERVER_PROP = OsmDataLayer.class.getName() + ".requiresUploadToServer";
+    private boolean requiresSaveToFile = false;
+    private boolean requiresUploadToServer = false;
+    protected void setRequiresSaveToFile(boolean newValue) {
+        boolean oldValue = requiresSaveToFile;
+        requiresSaveToFile = newValue;
+        if (oldValue != newValue) {
+            propertyChangeSupport.firePropertyChange(REQUIRES_SAVE_TO_DISK_PROP, oldValue, newValue);
+        }
+    }
+    protected void setRequiresUploadToServer(boolean newValue) {
+        boolean oldValue = requiresUploadToServer;
+        requiresUploadToServer = newValue;
+        if (oldValue != newValue) {
+            propertyChangeSupport.firePropertyChange(REQUIRES_UPLOAD_TO_SERVER_PROP, oldValue, newValue);
+        }
+    }
     /** the global counter for created data layers */
 …
         private void inc(final OsmPrimitive osm, final int i) {
             normal[i]++;
             if (osm.deleted) {
+            if (osm.isDeleted()) {
                 deleted[i]++;
+            }
 …
+    }
-    public interface ModifiedChangedListener {
-        void modifiedChanged(boolean value, OsmDataLayer source);
+    }
     public interface CommandQueueListener {
         void commandChanged(int queueSize, int redoSize);
 …
     private ConflictCollection conflicts;
-    /**
-     * Whether the data of this layer was modified during the session.
-     */
-    private boolean modified = false;
-    /**
-     * Whether the data was modified due an upload of the data to the server.
-     */
-    public boolean uploadedModified = false;
-    public final LinkedList<ModifiedChangedListener> listenerModified = new LinkedList<ModifiedChangedListener>();
     public final LinkedList<DataChangeListener> listenerDataChanged = new LinkedList<DataChangeListener>();
 …
     @Override public void visitBoundingBox(final BoundingXYVisitor v) {
         for (final Node n : data.nodes)
             if (!n.deleted && !n.incomplete) {
+            if (!n.isDeleted() && !n.incomplete) {
                 v.visit(n);
+            }
+    }
-    /**
-     * Cleanup the layer after save to disk. Just marks the layer as unmodified.
-     * Leaves the undo/redo stack unchanged.
+     *
-     */
-    public void cleanupAfterSaveToDisk() {
-        setModified(false);
+    }
 …
      */
     public void cleanupAfterUpload(final Collection<OsmPrimitive> processed) {
         // return immediately if an upload attempt failed
         if (processed == null || processed.isEmpty())
 …
             cleanIterator(it, processedSet);
+        }
-        setModified(true);
+    }
 …
         if (!processed.remove(osm))
             return;
         osm.modified = false;
         if (osm.deleted) {
+        osm.setModified(false);
+        if (osm.isDeleted()) {
             it.remove();
+        }
+    }
-    public boolean isModified() {
-        return modified;
+    }
-    public void setModified(final boolean modified) {
-        if (modified == this.modified)
-            return;
-        this.modified = modified;
-        for (final ModifiedChangedListener l : listenerModified) {
-            l.modifiedChanged(modified, this);
+        }
+    }
 …
         int size = 0;
         for (final OsmPrimitive osm : list)
             if (!osm.deleted) {
+            if (!osm.isDeleted()) {
                 size++;
+            }
 …
     public void fireDataChange() {
+        setRequiresSaveToFile(true);
+        setRequiresUploadToServer(true);
         for (DataChangeListener dcl : listenerDataChanged) {
             dcl.dataChanged(this);
 …
         HashSet<Node> doneNodes = new HashSet<Node>();
         for (Way w : data.ways) {
             if (w.incomplete || w.deleted) {
+            if (w.incomplete || w.isDeleted()) {
                 continue;
+            }
 …
             ArrayList<WayPoint> trkseg = null;
             for (Node n : w.getNodes()) {
                 if (n.incomplete || n.deleted) {
+                if (n.incomplete || n.isDeleted()) {
                     trkseg = null;
                     continue;
 …
         // records them?
         for (Node n : data.nodes) {
             if (n.incomplete || n.deleted || doneNodes.contains(n)) {
+            if (n.incomplete || n.isDeleted() || doneNodes.contains(n)) {
                 continue;
+            }
 …
         return conflicts;
+    }
+    /**
+     * Replies true if the data managed by this layer needs to be uploaded to
+     * the server because it contains at least one modified primitive.
+     *
+     * @return true if the data managed by this layer needs to be uploaded to
+     * the server because it contains at least one modified primitive; false,
+     * otherwise
+     */
+    public boolean requiresUploadToServer() {
+        return requiresUploadToServer;
+    }
+    /**
+     * Replies true if the data managed by this layer needs to be saved to
+     * a file. Only replies true if a file is assigned to this layer and
+     * if the data managed by this layer has been modified since the last
+     * save operation to the file.
+     *
+     * @return true if the data managed by this layer needs to be saved to
+     * a file
+     */
+    public boolean requiresSaveToFile() {
+        return getAssociatedFile() != null && requiresSaveToFile;
+    }
+    /**
+     * Initializes the layer after a successful load of OSM data from a file
+     *
+     */
+    public void onPostLoadFromFile() {
+        setRequiresSaveToFile(false);
+        setRequiresUploadToServer(data.isModified());
+    }
+    /**
+     * Initializes the layer after a successful save of OSM data to a file
+     *
+     */
+    public void onPostSaveToFile() {
+        setRequiresSaveToFile(false);
+        setRequiresUploadToServer(data.isModified());
+    }
+    /**
+     * Initializes the layer after a successful upload to the server
+     *
+     */
+    public void onPostUploadToServer() {
+        setRequiresUploadToServer(false);
+        // keep requiresSaveToDisk unchanged
+    }
+}

/trunk/src/org/openstreetmap/josm/gui/preferences/PreferenceDialog.java

-              r2024
+              r2060
 import java.awt.GridBagLayout;
 import java.awt.ScrollPane;
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
 import java.util.ArrayList;
 import java.util.Collection;
 …
  * @author imi
  */
+public class PreferenceDialog extends JTabbedPane {
+public class PreferenceDialog extends JTabbedPane implements MouseWheelListener {
     private final static Collection<PreferenceSettingFactory> settingsFactory = new LinkedList<PreferenceSettingFactory>();
 …
     public PreferenceDialog() {
         super(JTabbedPane.LEFT, JTabbedPane.SCROLL_TAB_LAYOUT);
+        super.addMouseWheelListener(this);
         for (PreferenceSettingFactory factory:settingsFactory) {
 …
         settingsFactory.add(new AdvancedPreference.Factory());
+    }
+    /**
+     * This mouse wheel listener reacts when a scroll is carried out over the
+     * tab strip and scrolls one tab/down or up, selecting it immediately.
+     */
+    public void mouseWheelMoved(MouseWheelEvent wev) {
+        // Ensure the cursor is over the tab strip
+        if(super.indexAtLocation(wev.getPoint().x, wev.getPoint().y) < 0)
+            return;
+        // Get currently selected tab
+        int newTab = super.getSelectedIndex() + wev.getWheelRotation();
+        // Ensure the new tab index is sound
+        newTab = newTab < 0 ? 0 : newTab;
+        newTab = newTab >= super.getTabCount() ? super.getTabCount() - 1 : newTab;
+        // select new tab
+        super.setSelectedIndex(newTab);
+    }
+}

/trunk/src/org/openstreetmap/josm/gui/progress/PleaseWaitProgressMonitor.java

-              r2024
+              r2060
     private PleaseWaitDialog dialog;
+    private String windowTitle;
     public PleaseWaitProgressMonitor() {
+        this("");
+    }
+    public PleaseWaitProgressMonitor(String windowTitle) {
         this(JOptionPane.getFrameForComponent(Main.map));
+        this.windowTitle = windowTitle;
+    }
 …
                     throw new ProgressException("PleaseWaitDialog parent must be either Frame or Dialog");
+                if (windowTitle != null) {
+                    dialog.setTitle(windowTitle);
+                }
                 dialog.cancel.setEnabled(true);
                 dialog.setCustomText("");

/trunk/src/org/openstreetmap/josm/gui/tagging/TaggingPreset.java

-              r2024
+              r2060
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 import javax.swing.AbstractAction;
 …
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.QuadStateCheckBox;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
 import org.openstreetmap.josm.io.MirroredInputStream;
 import org.openstreetmap.josm.tools.GBC;
 …
     public String locale_name;
+    private static AutoCompletionList autoCompletionList;
+    public static AutoCompletionList getPresetAutocompletionList() {
+        if (autoCompletionList == null) {
+            autoCompletionList = new AutoCompletionList();
+        }
+        return autoCompletionList;
+    }
     public static abstract class Item {
+        protected void initAutoCompletionField(AutoCompletingTextField field, String key) {
+            OsmDataLayer layer = Main.main.getEditLayer();
+            if (layer == null) return;
+            field.setAutoCompletionList(getPresetAutocompletionList());
+        }
         public boolean focus = false;
         abstract boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel);
 …
     public static class Usage {
+        Set<String> values;
+        Boolean hadKeys = false;
+        Boolean hadEmpty = false;
+        public Boolean allSimilar()
+        {
+        TreeSet<String> values;
+        boolean hadKeys = false;
+        boolean hadEmpty = false;
+        public boolean hasUniqueValue() {
             return values.size() == 1 && !hadEmpty;
+        }
+        public Boolean unused()
+        {
+        public boolean unused() {
             return values.size() == 0;
+        }
+        public String getFirst()
+        {
+            return (String)(values.toArray()[0]);
+        }
+        public Boolean hadKeys()
+        {
+        public String getFirst() {
+            return values.first();
+        }
+        public boolean hadKeys() {
             return hadKeys;
+        }
 …
     static Usage determineTextUsage(Collection<OsmPrimitive> sel, String key) {
         Usage returnValue = new Usage();
         returnValue.values = new HashSet<String>();
+        returnValue.values = new TreeSet<String>();
         for (OsmPrimitive s : sel) {
             String v = s.get(key);
 …
                 returnValue.hadEmpty = true;
+            }
             returnValue.hadKeys = returnValue.hadKeys | s.hasKeys();
+            returnValue.hadKeys = ! returnValue.values.isEmpty() | returnValue.hadEmpty;
+        }
         return returnValue;
 …
         Usage returnValue = new Usage();
         returnValue.values = new HashSet<String>();
+        returnValue.values = new TreeSet<String>();
         for (OsmPrimitive s : sel) {
             returnValue.values.add(OsmUtils.getNamedOsmBoolean(s.get(key)));
 …
         private JComponent value;
         @Override public boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel) {
             // find out if our key is already used in the selection.
             Usage usage = determineTextUsage(sel, key);
+            if (usage.unused())
+            {
                 value = new JTextField();
+            if (usage.unused()){
+                AutoCompletingTextField textField = new AutoCompletingTextField();
+                initAutoCompletionField(textField, key);
                 if (use_last_as_default && lastValue.containsKey(key)) {
                     ((JTextField)value).setText(lastValue.get(key));
+                    textField.setText(lastValue.get(key));
                 } else {
+                    ((JTextField)value).setText(default_);
+                }
+                    textField.setText(default_);
+                }
+                value = textField;
                 originalValue = null;
             } else if (usage.allSimilar()) {
+            } else if (usage.hasUniqueValue()) {
                 // all objects use the same value
                 value = new JTextField();
                 for (String s : usage.values) {
                     ((JTextField) value).setText(s);
+                }
                 originalValue = ((JTextField)value).getText();
+                AutoCompletingTextField textField = new AutoCompletingTextField();
+                initAutoCompletionField(textField, key);
+                textField.setText(usage.getFirst());
+                value = textField;
+                originalValue = usage.getFirst();
             } else {
                 // the objects have different values
+                value = new JComboBox(usage.values.toArray());
+                ((JComboBox)value).setEditable(true);
+                ((JComboBox)value).getEditor().setItem(DIFFERENT);
+                AutoCompletingTextField textField = new AutoCompletingTextField();
+                initAutoCompletionField(textField, key);
+                JComboBox comboBox = new JComboBox(usage.values.toArray());
+                comboBox.setEditable(true);
+                comboBox.setEditor(textField);
+                comboBox.getEditor().setItem(DIFFERENT);
+                value=comboBox;
                 originalValue = DIFFERENT;
+            }
 …
             lhm = new LinkedHashMap<String,String>();
+            if (!usage.allSimilar() && !usage.unused())
+            {
+            if (!usage.hasUniqueValue() && !usage.unused()){
                 lhm.put(DIFFERENT, DIFFERENT);
+            }
 …
                                 tr(display_array[i]) : display_array[i]);
+            }
+            if(!usage.unused())
+            {
+            if(!usage.unused()){
                 for (String s : usage.values) {
                     if (!lhm.containsKey(s)) {
 …
             combo = new JComboBox(lhm.values().toArray());
             combo.setEditable(editable);
+            if (usage.allSimilar() && !usage.unused())
+            {
+            AutoCompletingTextField tf = new AutoCompletingTextField();
+            initAutoCompletionField(tf, key);
+            tf.getAutoCompletionList().add(Arrays.asList(display_array), AutoCompletionItemPritority.IS_IN_STANDARD);
+            combo.setEditor(tf);
+            if (usage.hasUniqueValue() && !usage.unused()){
                 originalValue=usage.getFirst();
                 combo.setSelectedItem(lhm.get(originalValue));
+            }
             // use default only in case it is a totally new entry
+            else if(default_ != null && !usage.hadKeys())
+            {
+            else if(default_ != null && !usage.hadKeys()) {
                 combo.setSelectedItem(default_);
                 originalValue=DIFFERENT;
+            }
+            else if(usage.unused())
+            {
+            else if(usage.unused()){
                 combo.setSelectedItem("");
                 originalValue="";
+            }
+            else
+            {
+            else{
                 combo.setSelectedItem(DIFFERENT);
                 originalValue=DIFFERENT;
 …
+    }
+    protected void refreshAutocompletionList(final OsmDataLayer layer) {
+        Runnable task = new Runnable() {
+            public void run() {
+                System.out.print("refreshing preset auto completion list ...");
+                AutoCompletionCache.getCacheForLayer(layer).initFromDataSet();
+                AutoCompletionCache.getCacheForLayer(layer).populateWithValues( getPresetAutocompletionList(), false /* don't append */);
+                System.out.println("DONE");
+            }
+        };
+        new Thread(task).run();
+    }
     public PresetPanel createPanel(Collection<OsmPrimitive> selected) {
         if (data == null)
             return null;
+        OsmDataLayer layer = Main.main.getEditLayer();
+        if (layer != null) {
+            refreshAutocompletionList(layer);
+        }
         PresetPanel p = new PresetPanel();
         LinkedList<Item> l = new LinkedList<Item>();
+        if(types != null)
+        {
+        if(types != null){
             JPanel pp = new JPanel();
+            for(String t : types)
+            {
+            for(String t : types){
                 JLabel la = new JLabel(ImageProvider.get("Mf_" + t));
                 la.setToolTipText(tr("Elements of type {0} are supported.", tr(t)));
 …
+        }
+        for (Item i : data)
+        {
+        for (Item i : data){
             if(i instanceof Link) {
                 l.add(i);
+            } else
+            {
+            } else {
                 if(i.addToPanel(p, selected)) {
                     p.hasElements = true;
 …
                             true);
                     contentConstraints = GBC.eol().fill().insets(5,10,5,0);
+                    setupDialog(content, new String[] {"ok.png", "cancel.png" });
+                    setButtonIcons(new String[] {"ok.png", "cancel.png" });
+                    setContent(content);
+                    setupDialog();
                     buttons.get(0).setEnabled(!disableApply);
                     buttons.get(0).setToolTipText(title);

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

-              r2024
+              r2060
     public void visit(Node n) {
         String key = "node:" + (newIdMap.containsKey(n) ? newIdMap.get(n) : n.id);
+        String key = "node:" + (newIdMap.containsKey(n) ? newIdMap.get(n) : n.getId());
         System.out.println("key: "+key);
         Long[] nv = versions.get(key);
         if (nv != null) {
             processed.add(n);
             if (!n.deleted) {
+            if (!n.isDeleted()) {
                 n.id = nv[0]; n.version = nv[1].intValue();
+            }
 …
+    }
     public void visit(Way w) {
         String key = "way:" + (newIdMap.containsKey(w) ? newIdMap.get(w) : w.id);
+        String key = "way:" + (newIdMap.containsKey(w) ? newIdMap.get(w) : w.getId());
         Long[] nv = versions.get(key);
         if (nv != null) {
             processed.add(w);
             if (!w.deleted) {
+            if (!w.isDeleted()) {
                 w.id = nv[0]; w.version = nv[1].intValue();
+            }
 …
+    }
     public void visit(Relation r) {
         String key = "relation:" + (newIdMap.containsKey(r) ? newIdMap.get(r) : r.id);
+        String key = "relation:" + (newIdMap.containsKey(r) ? newIdMap.get(r) : r.getId());
         Long[] nv = versions.get(key);
         if (nv != null) {
             processed.add(r);
             if (!r.deleted) {
+            if (!r.isDeleted()) {
                 r.id = nv[0]; r.version = nv[1].intValue();
+            }

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

-              r2024
+              r2060
         p.add(keywords, GBC.eop().fill(GBC.HORIZONTAL));
+        int answer = new ExtendedDialog(Main.parent, tr("Export options"), p, new String[] { tr("Export and Save"),
+            tr("Cancel") }, new String[] { "exportgpx.png", "cancel.png" }).getValue();
+        if (answer != 1)
+        ExtendedDialog ed = new ExtendedDialog(Main.parent,
+                tr("Export options"),
+                new String[] { tr("Export and Save"), tr("Cancel") });
+        ed.setButtonIcons(new String[] { "exportgpx.png", "cancel.png" });
+        ed.setContent(p);
+        ed.showDialog();
+        if (ed.getValue() != 1)
             return;

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

-              r2024
+              r2060
     public MultiFetchServerObjectReader append(Node node) {
         if (node == null) return this;
         if (node.id == 0) return this;
         remember(node.id, OsmPrimitiveType.NODE);
+        if (node.getId() == 0) return this;
+        remember(node.getId(), OsmPrimitiveType.NODE);
         return this;
+    }
 …
     public MultiFetchServerObjectReader append(Way way) {
         if (way == null) return this;
         if (way.id == 0) return this;
+        if (way.getId() == 0) return this;
         for (Node node: way.getNodes()) {
             if (node.id > 0) {
                 remember(node.id, OsmPrimitiveType.NODE);
+            }
+        }
         remember(way.id, OsmPrimitiveType.WAY);
+            if (node.getId() > 0) {
+                remember(node.getId(), OsmPrimitiveType.NODE);
+            }
+        }
+        remember(way.getId(), OsmPrimitiveType.WAY);
         return this;
+    }
 …
     public MultiFetchServerObjectReader append(Relation relation) {
         if (relation == null) return this;
         if (relation.id == 0) return this;
         remember(relation.id, OsmPrimitiveType.RELATION);
+        if (relation.getId() == 0) return this;
+        remember(relation.getId(), OsmPrimitiveType.RELATION);
         for (RelationMember member : relation.getMembers()) {
             if (OsmPrimitiveType.from(member.member).equals(OsmPrimitiveType.RELATION)) {
                 // avoid infinite recursion in case of cyclic dependencies in relations
                 //
                 if (relations.contains(member.member.id)) {
+                if (relations.contains(member.member.getId())) {
                     continue;
+                }
 …
                 String msg = "";
                 switch(type) {
+                case NODE: msg = tr("Fetching node with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                case WAY: msg = tr("Fetching way with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                case RELATION: msg = tr("Fetching relation with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                    case NODE: msg = tr("Fetching node with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                    case WAY: msg = tr("Fetching way with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                    case RELATION: msg = tr("Fetching relation with id {0} from ''{1}''", id, OsmApi.getOsmApi().getBaseUrl()); break;
+                }
                 progressMonitor.setCustomText(msg);
 …
         String msg = "";
         switch(type) {
+        case NODE: msg = tr("Fetching a package of nodes from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+        case WAY:  msg = tr("Fetching a package of ways from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+        case RELATION:  msg = tr("Fetching a package of relations from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+            case NODE: msg = tr("Fetching a package of nodes from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+            case WAY:  msg = tr("Fetching a package of ways from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+            case RELATION:  msg = tr("Fetching a package of relations from ''{0}''", OsmApi.getOsmApi().getBaseUrl()); break;
+        }
         progressMonitor.setCustomText(msg);

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

-              r2024
+              r2060
     /**
      * Returns true if the negotiated version supports changesets.
      * @return true if the negotiated version supports changesets.
+     */
     public boolean hasChangesetSupport() {
+     * Returns true if the negotiated version supports diff uploads.
+     * @return true if the negotiated version supports diff uploads
+     */
+    public boolean hasSupportForDiffUploads() {
         return ((version != null) && (version.compareTo("0.6")>=0));
+    }
 …
      * @exception OsmApiInitializationException thrown, if an exception occurs
      */
+    public void initialize() throws OsmApiInitializationException {
+    public void initialize(ProgressMonitor monitor) throws OsmApiInitializationException {
         if (initialized)
             return;
+        cancel = false;
         initAuthentication();
         try {
+            String s = sendRequest("GET", "capabilities", null);
+            String s = sendRequest("GET", "capabilities", null,monitor);
             InputSource inputSource = new InputSource(new StringReader(s));
             SAXParserFactory.newInstance().newSAXParser().parse(inputSource, new CapabilitiesParser());
 …
      * @throws OsmTransferException if something goes wrong
      */
+    public void createPrimitive(OsmPrimitive osm) throws OsmTransferException {
+        initialize();
+    public void createPrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
+        initialize(monitor);
         String ret = "";
         try {
+            ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/create", toXml(osm, true));
+            ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/create", toXml(osm, true),monitor);
             osm.id = Long.parseLong(ret.trim());
             osm.version = 1;
 …
      * @throws OsmTransferException if something goes wrong
      */
+    public void modifyPrimitive(OsmPrimitive osm) throws OsmTransferException {
+        initialize();
+    public void modifyPrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
+        initialize(monitor);
         if (version.equals("0.5")) {
             // legacy mode does not return the new object version.
             sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.id, toXml(osm, true));
+            sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.getId(), toXml(osm, true),monitor);
         } else {
             String ret = null;
             // normal mode (0.6 and up) returns new object version.
             try {
                 ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.id, toXml(osm, true));
+                ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.getId(), toXml(osm, true), monitor);
                 osm.version = Integer.parseInt(ret.trim());
             } catch(NumberFormatException e) {
                 throw new OsmTransferException(tr("unexpected format of new version of modified primitive ''{0}'', got ''{1}''", osm.id, ret));
+                throw new OsmTransferException(tr("unexpected format of new version of modified primitive ''{0}'', got ''{1}''", osm.getId(), ret));
+            }
+        }
 …
      */
     public void deletePrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
+        initialize();
+        initialize(monitor);
         // can't use a the individual DELETE method in the 0.6 API. Java doesn't allow
         // submitting a DELETE request with content, the 0.6 API requires it, however. Falling back
 …
     /**
+     * Creates a new changeset on the server to use for subsequent calls.
+     * @param comment the "commit comment" for the new changeset
+     * Creates the changeset to be used for subsequent uploads.
+     *
+     * If changesetProcessingType is {@see ChangesetProcessingType#USE_NEW} creates a new changeset based
+     * on <code>changeset</code>. Otherwise uses the changeset given by {@see OsmApi#getCurrentChangeset()}.
+     * If this changeset is null or has an id of value 0, a new changeset is created too.
+     *
+     * @param changeset the changeset to be used for uploading if <code>changesetProcessingType</code> is
+     *   {@see ChangesetProcessingType#USE_NEW}
+     * @param changesetProcessingType  how to handel changesets; set to {@see ChangesetProcessingType#USE_NEW} if null
+     * @param progressMonitor the progress monitor
      * @throws OsmTransferException signifying a non-200 return code, or connection errors
      */
+    public void createChangeset(String comment, ProgressMonitor progressMonitor) throws OsmTransferException {
+        progressMonitor.beginTask((tr("Opening changeset...")));
+    public void createChangeset(Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
+        if (changesetProcessingType == null) {
+            changesetProcessingType = ChangesetProcessingType.USE_NEW_AND_CLOSE;
+        }
         try {
+            changeset = new Changeset();
+            Properties sysProp = System.getProperties();
+            Object ua = sysProp.get("http.agent");
+            changeset.put("created_by", (ua == null) ? "JOSM" : ua.toString());
+            changeset.put("comment", comment);
+            createPrimitive(changeset);
+            progressMonitor.beginTask((tr("Creating changeset...")));
+            if (changesetProcessingType.isUseNew()) {
+                Properties sysProp = System.getProperties();
+                Object ua = sysProp.get("http.agent");
+                changeset.put("created_by", (ua == null) ? "JOSM" : ua.toString());
+                createPrimitive(changeset, progressMonitor);
+                this.changeset = changeset;
+                progressMonitor.setCustomText((tr("Successfully opened changeset {0}",changeset.getId())));
+            } else {
+                if (this.changeset == null || this.changeset.getId() == 0) {
+                    progressMonitor.setCustomText((tr("No currently open changeset. Opening a new changeset...")));
+                    System.out.println(tr("Warning: could not reuse an existing changeset as requested. Opening a new one."));
+                    Properties sysProp = System.getProperties();
+                    Object ua = sysProp.get("http.agent");
+                    changeset.put("created_by", (ua == null) ? "JOSM" : ua.toString());
+                    createPrimitive(changeset, progressMonitor);
+                    this.changeset = changeset;
+                    progressMonitor.setCustomText((tr("Successfully opened changeset {0}",this.changeset.getId())));
+                } else {
+                    progressMonitor.setCustomText((tr("Reusing existing changeset {0}", this.changeset.getId())));
+                }
+            }
         } finally {
             progressMonitor.finishTask();
 …
      * Closes a changeset on the server.
+     *
+     * @param changesetProcessingType how changesets are currently handled
+     * @param progressMonitor the progress monitor
+     *
      * @throws OsmTransferException if something goes wrong.
      */
+    public void stopChangeset(ProgressMonitor progressMonitor) throws OsmTransferException {
+        progressMonitor.beginTask(tr("Closing changeset..."));
+    public void stopChangeset(ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
+        if (changesetProcessingType == null) {
+            changesetProcessingType = ChangesetProcessingType.USE_NEW_AND_CLOSE;
+        }
         try {
+            initialize();
+            sendRequest("PUT", "changeset" + "/" + changeset.id + "/close", null);
+            changeset = null;
+            progressMonitor.beginTask(tr("Closing changeset..."));
+            initialize(progressMonitor);
+            if (changesetProcessingType.isCloseAfterUpload()) {
+                progressMonitor.setCustomText(tr("Closing changeset {0}...", changeset.getId()));
+                if (this.changeset != null && this.changeset.getId() > 0) {
+                    sendRequest("PUT", "changeset" + "/" + changeset.getId() + "/close", null, progressMonitor);
+                    changeset = null;
+                }
+            } else {
+                progressMonitor.setCustomText(tr("Leaving changeset {0} open...", changeset.getId()));
+            }
         } finally {
             progressMonitor.finishTask();
 …
                 throw new OsmTransferException(tr("No changeset present for diff upload"));
+            initialize();
+            initialize(progressMonitor);
             final ArrayList<OsmPrimitive> processed = new ArrayList<OsmPrimitive>();
 …
             String diff = duv.getDocument();
             try {
                 String diffresult = sendRequest("POST", "changeset/" + changeset.id + "/upload", diff);
+                String diffresult = sendRequest("POST", "changeset/" + changeset.getId() + "/upload", diff,progressMonitor);
                 DiffResultReader.parseDiffResult(diffresult, list, processed, duv.getNewIdMap(),
                         progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
 …
+    private void sleepAndListen() throws OsmTransferCancelledException {
+    private void sleepAndListen(int retry, ProgressMonitor monitor) throws OsmTransferCancelledException {
         System.out.print(tr("Waiting 10 seconds ... "));
         for(int i=0; i < 10; i++) {
+            if (monitor != null) {
+                monitor.setCustomText(tr("Starting retry {0} of {1} in {2} seconds ...", getMaxRetries() - retry,getMaxRetries(), 10-i));
+            }
             if (cancel || isAuthCancelled())
                 throw new OsmTransferCancelledException();
 …
      *    been exhausted), or rewrapping a Java exception.
      */
+    private String sendRequest(String requestMethod, String urlSuffix,
+            String requestBody) throws OsmTransferException {
+    private String sendRequest(String requestMethod, String urlSuffix,String requestBody, ProgressMonitor monitor) throws OsmTransferException {
         StringBuffer responseBody = new StringBuffer();
 …
                 if (retCode >= 500) {
                     if (retries-- > 0) {
+                        sleepAndListen();
+                        int maxRetries = getMaxRetries();
+                        System.out.println(tr("Starting retry {0} of {1}.", maxRetries - retries,maxRetries));
+                        sleepAndListen(retries, monitor);
+                        System.out.println(tr("Starting retry {0} of {1}.", getMaxRetries() - retries,getMaxRetries()));
                         continue;
+                    }

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

-              r2024
+              r2060
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 import org.openstreetmap.josm.tools.Base64;
 import org.openstreetmap.josm.tools.GBC;
 …
     public void cancel() {
-        //TODO
-        //Main.pleaseWaitDlg.currentAction.setText(tr("Aborting..."));
         cancel = true;
         if (activeConnection != null) {
 …
         try {
             synchronized (credentialsManager) {
                 auth = credentialsManager.lookup(CredentialsManager.Key.USERNAME) + ":" +
                     credentialsManager.lookup(CredentialsManager.Key.PASSWORD);
+                auth = credentialsManager.lookup(CredentialsManager.Key.USERNAME) + ":" +
+                credentialsManager.lookup(CredentialsManager.Key.PASSWORD);
+            }
         } catch (CredentialsManager.CMException e) {
 …
             String secret = Main.pref.get("osm-server." + key.toString(), null);
             if (secret == null) throw new CredentialsManager.NoContentException();
             return secret;
+            return secret;
+        }
         public void store(CredentialsManager.Key key, String secret) {
 …
                 p.add(warning, GBC.eop());
                 JCheckBox savePassword = new JCheckBox(tr("Save user and password (unencrypted)"),
                                                        !username.equals("") && !password.equals(""));
+                JCheckBox savePassword = new JCheckBox(tr("Save user and password (unencrypted)"),
+                        !username.equals("") && !password.equals(""));
                 p.add(savePassword, GBC.eop());
+                int choice = new ExtendedDialog(
+                    Main.parent,
+                    tr("Enter Password"),
+                    p,
+                    new String[] {tr("Login"), tr("Cancel")},
+                    new String[] {"ok.png", "cancel.png"}).getValue();
+                if (choice != 1) {
+                ExtendedDialog dialog = new ExtendedDialog(
+                        Main.parent,
+                        tr("Enter Password"),
+                        new String[] {tr("Login"), tr("Cancel")}
+                );
+                dialog.setContent(p);
+                dialog.setButtonIcons( new String[] {"ok.png", "cancel.png"});
+                dialog.showDialog();
+                if (dialog.getValue() != 1) {
                     caller.authCancelled = true;
                     return null;
 …
                         oldServerURL = "";
+                    }
+                    if (oldServerURL.equals("")) oldServerURL = "http://api.openstreetmap.org/api";
+                    if (oldServerURL.equals("")) {
+                        oldServerURL = "http://api.openstreetmap.org/api";
+                    }
                     try {
                         oldUsername = lookup(Key.USERNAME);
 …
                     String newPassword = String.valueOf(osmDataPassword.getPassword());
                     if (!oldServerURL.equals(newServerURL)) {
                         store(Key.OSM_SERVER_URL, newServerURL);
+                        store(Key.OSM_SERVER_URL, newServerURL);
+                    }
                     if (!oldUsername.equals(newUsername)) {

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

r2024	r2060
76	76	tmpFile.delete();
77	77	}
78		layer.~~cleanupAfterSaveToDisk~~();
	78	layer.onPostSaveToFile();
79	79	} catch (IOException e) {
80	80	e.printStackTrace();

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

-              r2024
+              r2060
 import java.io.IOException;
 import java.io.InputStream;
+import javax.swing.SwingUtilities;
 import org.openstreetmap.josm.Main;
 …
         OsmReader osm = OsmReader.parseDataSetOsm(in, NullProgressMonitor.INSTANCE);
         DataSet dataSet = osm.getDs();
+        OsmDataLayer layer = new OsmDataLayer(dataSet, associatedFile.getName(), associatedFile);
+        Main.main.addLayer(layer);
+        layer.fireDataChange();
+        final OsmDataLayer layer = new OsmDataLayer(dataSet, associatedFile.getName(), associatedFile);
+        // FIXME: remove UI stuff from IO subsystem
+        //
+        Runnable uiStuff = new Runnable() {
+            public void run() {
+                Main.main.addLayer(layer);
+                layer.fireDataChange();
+                layer.onPostLoadFromFile();
+            }
+        };
+        if (SwingUtilities.isEventDispatchThread()) {
+            uiStuff.run();
+        } else {
+            SwingUtilities.invokeLater(uiStuff);
+        }
+    }
+}

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

r2024	r2060
40	40	protected InputStream getInputStream(String urlStr, ProgressMonitor progressMonitor) throws OsmTransferException {
41	41	try {
42		api.initialize();
	42	api.initialize(progressMonitor);
43	43	urlStr = api.getBaseUrl() + urlStr;
44	44	return getInputStreamRaw(urlStr, progressMonitor);

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

-              r2024
+              r2060
+     *
      * @param primitives the collection of primitives to upload
+     * @param changeset the changeset to be used if <code>changesetProcessingType</code> indicates that
+     *   a new changeset should be opened
+     * @param changesetProcessingType how we handle changesets
      * @param progressMonitor the progress monitor
      * @throws OsmTransferException thrown if an exception occurs
      */
+    protected void uploadChangesIndividually(Collection<OsmPrimitive> primitives, ProgressMonitor progressMonitor) throws OsmTransferException {
+    protected void uploadChangesIndividually(Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
         try {
             progressMonitor.setTicksCount(primitives.size());
             api.createChangeset(getChangesetComment(), progressMonitor.createSubTaskMonitor(0, false));
+            api.createChangeset(changeset, changesetProcessingType,progressMonitor.createSubTaskMonitor(0, false));
             uploadStartTime = System.currentTimeMillis();
             for (OsmPrimitive osm : primitives) {
 …
                 String msg = "";
                 switch(OsmPrimitiveType.from(osm)) {
+                case NODE: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading node ''{4}'' (id: {5})"); break;
+                case WAY: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading way ''{4}'' (id: {5})"); break;
+                case RELATION: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading relation ''{4}'' (id: {5})"); break;
+                    case NODE: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading node ''{4}'' (id: {5})"); break;
+                    case WAY: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading way ''{4}'' (id: {5})"); break;
+                    case RELATION: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading relation ''{4}'' (id: {5})"); break;
+                }
                 progressMonitor.subTask(
 …
                                 primitives.size(),
                                 time_left_str,
                                 osm.getName() == null ? osm.id : osm.getName(),
                                         osm.id));
+                                osm.getName() == null ? osm.getId() : osm.getName(),
+                                        osm.getId()));
                 makeApiRequest(osm,progressMonitor);
                 processed.add(osm);
 …
         } finally {
             try {
+                api.stopChangeset(progressMonitor.createSubTaskMonitor(0, false));
+                // starting the changeset may have failed, for instance because the user
+                // cancelled the upload task. Only close the changeset if we currently have
+                // an open changeset
+                if (api.getCurrentChangeset() != null && api.getCurrentChangeset().getId() > 0) {
+                    api.stopChangeset(changesetProcessingType, progressMonitor.createSubTaskMonitor(0, false));
+                }
             } catch(Exception e) {
+                Changeset changeset = api.getCurrentChangeset();
+                String changesetId = (changeset == null ? tr("unknown") : Long.toString(changeset.id));
+                logger.warning(tr("Failed to close changeset {0}, will be closed by server after timeout. Exception was: {1}",
+                        changesetId, e.toString()));
+                OsmChangesetCloseException closeException = new OsmChangesetCloseException(e);
+                closeException.setChangeset(api.getCurrentChangeset());
+                throw closeException;
+            }
+        }
 …
      * @throws OsmTransferException thrown if an exception occurs
      */
+    protected void uploadChangesAsDiffUpload(Collection<OsmPrimitive> primitives, ProgressMonitor progressMonitor) throws OsmTransferException {
+    protected void uploadChangesAsDiffUpload(Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
         // upload everything in one changeset
         //
         try {
             api.createChangeset(getChangesetComment(), progressMonitor.createSubTaskMonitor(0, false));
+            api.createChangeset(changeset, changesetProcessingType, progressMonitor.createSubTaskMonitor(0, false));
             processed.addAll(api.uploadDiff(primitives, progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false)));
         } catch(OsmTransferException e) {
 …
         } finally {
             try {
+                api.stopChangeset(progressMonitor.createSubTaskMonitor(0, false));
+                api.stopChangeset(changesetProcessingType, progressMonitor.createSubTaskMonitor(0, false));
             } catch (Exception ee) {
+                Changeset changeset = api.getCurrentChangeset();
+                String changesetId = (changeset == null ? tr("unknown") : Long.toString(changeset.id));
+                logger.warning(tr("Failed to close changeset {0}, will be closed by server after timeout. Exception was: {1}",
+                        changesetId, ee.toString()));
+                OsmChangesetCloseException closeException = new OsmChangesetCloseException(ee);
+                closeException.setChangeset(api.getCurrentChangeset());
+                throw closeException;
+            }
+        }
 …
      * @param primitives list of objects to send
      */
+    public void uploadOsm(String apiVersion, Collection<OsmPrimitive> primitives, ProgressMonitor progressMonitor) throws OsmTransferException {
+    public void uploadOsm(String apiVersion, Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
         processed = new LinkedList<OsmPrimitive>();
+        api.initialize();
+        progressMonitor.beginTask("");
+        api.initialize(progressMonitor);
         try {
             // check whether we can use changeset
+            // check whether we can use diff upload
             //
+            boolean canUseChangeset = api.hasChangesetSupport();
+            boolean useChangeset = Main.pref.getBoolean("osm-server.atomic-upload", apiVersion.compareTo("0.6")>=0);
+            if (useChangeset && ! canUseChangeset) {
+                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));
+                useChangeset = false;
+            }
+            if (useChangeset) {
+                uploadChangesAsDiffUpload(primitives, progressMonitor);
+            boolean casUseDiffUploads = api.hasSupportForDiffUploads();
+            boolean useDiffUpload = Main.pref.getBoolean("osm-server.atomic-upload", apiVersion.compareTo("0.6")>=0);
+            if (useDiffUpload && ! casUseDiffUploads) {
+                System.out.println(tr("WARNING: preference ''{0}'' or api version ''{1}'' of dataset requires to use diff uploads, but API is not able to handle them. Ignoring diff upload.", "osm-server.atomic-upload", apiVersion));
+                useDiffUpload = false;
+            }
+            if (useDiffUpload) {
+                progressMonitor.beginTask(tr("Starting to upload in one request ..."));
+                uploadChangesAsDiffUpload(primitives,changeset, changesetProcessingType, progressMonitor);
             } else {
+                uploadChangesIndividually(primitives, progressMonitor);
+                progressMonitor.beginTask(tr("Starting to upload with one request per primitive ..."));
+                uploadChangesIndividually(primitives,changeset,changesetProcessingType,  progressMonitor);
+            }
         } finally {
 …
     void makeApiRequest(OsmPrimitive osm, ProgressMonitor progressMonitor) throws OsmTransferException {
         if (osm.deleted) {
+        if (osm.isDeleted()) {
             api.deletePrimitive(osm, progressMonitor);
         } else if (osm.id == 0) {
+            api.createPrimitive(osm);
+        } else if (osm.getId() == 0) {
+            api.createPrimitive(osm, progressMonitor);
         } else {
+            api.modifyPrimitive(osm);
+        }
+    }
     public void disconnectActiveConnection() {
         if (api != null && api.activeConnection != null) {
             api.activeConnection.disconnect();
+            api.modifyPrimitive(osm,progressMonitor);
+        }
+    }
+    public void cancel() {
+        if (api != null) {
+            api.cancel();
+        }
+    }

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

-              r2024
+              r2060
     private boolean shouldWrite(OsmPrimitive osm) {
         return osm.id != 0 || !osm.deleted;
+        return osm.getId() != 0 || !osm.isDeleted();
+    }
 …
      */
     private long getUsedId(OsmPrimitive osm) {
         if (osm.id != 0)
             return osm.id;
+        if (osm.getId() != 0)
+            return osm.getId();
         if (usedNewIds.containsKey(osm))
             return usedNewIds.get(osm);
 …
+            }
             for (Entry<String, String> e : osm.entrySet()) {
+                if ((osm instanceof Changeset) || !("created_by".equals(e.getKey())))
+                if ((osm instanceof Changeset) || !("created_by".equals(e.getKey()))) {
                     out.println("    <tag k='"+ XmlWriter.encode(e.getKey()) +
                             "' v='"+XmlWriter.encode(e.getValue())+ "' />");
+                }
+            }
             out.println("  </" + tagname + ">");
 …
         if (!osmConform) {
             String action = null;
             if (osm.deleted) {
+            if (osm.isDeleted()) {
                 action = "delete";
             } else if (osm.modified) {
+            } else if (osm.isModified()) {
                 action = "modify";
+            }
 …
             out.print(" user='"+XmlWriter.encode(osm.user.name)+"'");
+        }
         out.print(" visible='"+osm.visible+"'");
+        out.print(" visible='"+osm.isVisible()+"'");
         if (osm.version != -1) {
             out.print(" version='"+osm.version+"'");
+        }
         if (this.changeset != null && this.changeset.id != 0) {
             out.print(" changeset='"+this.changeset.id+"'" );
+        if (this.changeset != null && this.changeset.getId() != 0) {
+            out.print(" changeset='"+this.changeset.getId()+"'" );
+        }
+    }

/trunk/src/org/openstreetmap/josm/plugins/PluginSelection.java

-              r2024
+              r2060
             done = true;
         } else {
             int answer = new ExtendedDialog(Main.parent,
+            ExtendedDialog ed = new ExtendedDialog(Main.parent,
                     tr("Update"),
+                    tr("Update the following plugins:\n\n{0}", toUpdateStr.toString()),
+                    new String[] {tr("Update Plugins"), tr("Cancel")},
+                    new String[] {"dialogs/refresh.png", "cancel.png"}).getValue();
+            if (answer == 1) {
+                    new String[] {tr("Update Plugins"), tr("Cancel")});
+            ed.setButtonIcons(new String[] {"dialogs/refresh.png", "cancel.png"});
+            ed.setContent(tr("Update the following plugins:\n\n{0}", toUpdateStr.toString()));
+            ed.showDialog();
+            if (ed.getValue() == 1) {
                 PluginDownloader.update(toUpdate);
                 done = true;
 …
+        }
         if (!toDownload.isEmpty()) {
             int answer = new ExtendedDialog(Main.parent,
+            ExtendedDialog ed = new ExtendedDialog(Main.parent,
                     tr("Download missing plugins"),
+                    tr("Download the following plugins?\n\n{0}", msg),
+                    new String[] {tr("Download Plugins"), tr("Cancel")},
+                    new String[] {"download.png", "cancel.png"}).getValue();
+                    new String[] {tr("Download Plugins"), tr("Cancel")});
+            ed.setButtonIcons(new String[] {"download.png", "cancel.png"});
+            ed.setContent(tr("Download the following plugins?\n\n{0}", msg));
+            ed.showDialog();
             Collection<PluginInformation> error =
                 (answer != 1 ? toDownload : new PluginDownloader().download(toDownload));
+                (ed.getValue() != 1 ? toDownload : new PluginDownloader().download(toDownload));
             for (PluginInformation pd : error) {
                 pluginMap.put(pd.name, false);

/trunk/src/org/openstreetmap/josm/tools/PlatformHookOsx.java

r2024	r2060
48	48	//System.out.println("Going to handle method "+method+" (short: "+method.getName()+") with event "+args[0]);
49	49	if (method.getName().equals("handleQuit")) {
50		handled = ~~!Main.breakBecaus~~eUnsaved~~Change~~s();
	50	handled = Main.saveUnsavedModifications();
51	51	} else if (method.getName().equals("handleAbout")) {
52	52	Main.main.menu.about.actionPerformed(null);

/trunk/test/functional/org/openstreetmap/josm/io/MultiFetchServerObjectReaderTest.java

r2024	r2060
127	127
128	128	OsmServerWriter writer = new OsmServerWriter();
129		writer.uploadOsm("0.6", primitives, NullProgressMonitor.INSTANCE);
	129	writer.uploadOsm("0.6", primitives, null,null, NullProgressMonitor.INSTANCE);
130	130	}
131	131

/trunk/test/functional/org/openstreetmap/josm/io/OsmServerBackreferenceReaderTest.java

r2024	r2060
129	129	primitives.addAll(ds.relations);
130	130	OsmServerWriter writer = new OsmServerWriter();
131		writer.uploadOsm("0.6", primitives, NullProgressMonitor.INSTANCE);
	131	writer.uploadOsm("0.6", primitives, null, null, NullProgressMonitor.INSTANCE);
132	132	}
133	133

Context Navigation

Changes in / [2024:2060] in josm

Legend:

Download in other formats: