Index: trunk/src/org/openstreetmap/josm/actions/PurgeAction.java =================================================================== --- trunk/src/org/openstreetmap/josm/actions/PurgeAction.java (revision 3431) +++ trunk/src/org/openstreetmap/josm/actions/PurgeAction.java (revision 3431) @@ -0,0 +1,266 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.actions; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.Component; +import java.awt.Dimension; +import java.awt.GridBagLayout; +import java.awt.Insets; +import java.awt.event.ActionEvent; +import java.awt.event.KeyEvent; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import javax.swing.AbstractAction; +import javax.swing.BorderFactory; +import javax.swing.Box; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JLabel; +import javax.swing.JList; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JSeparator; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.command.PurgeCommand; +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.gui.ExtendedDialog; +import org.openstreetmap.josm.gui.OsmPrimitivRenderer; +import org.openstreetmap.josm.gui.help.HelpUtil; +import org.openstreetmap.josm.gui.layer.OsmDataLayer; +import org.openstreetmap.josm.tools.GBC; +import org.openstreetmap.josm.tools.ImageProvider; +import org.openstreetmap.josm.tools.Shortcut; + +/** + * The action to purge the selected primitives, i.e. remove them from the + * data layer, or remove their content and make them incomplete. + * + * This means, the deleted flag is not affected and JOSM simply forgets + * about these primitives. + * + * This action is undo-able. In order not to break previous commands in the + * undo buffer, we must re-add the identical object (and not semantically + * equal ones). + */ +public class PurgeAction extends JosmAction { + + public PurgeAction() { + /* translator note: other expressions for "purge" might be "forget", "clean", "obliterate", "prune" */ + super(tr("Purge..."), "purge", tr("Forget objects but do not delete them on server when uploading."), + Shortcut.registerShortcut("system:purge", tr("Edit: {0}", tr("Purge")), KeyEvent.VK_P, Shortcut.GROUP_MENU, Shortcut.SHIFT_DEFAULT) + , true); + putValue("help", HelpUtil.ht("/Action/Purge")); + } + + protected OsmDataLayer layer; + JCheckBox cbClearUndoRedo; + + protected Set toPurge; + /** + * finally, contains all objects that are purged + */ + protected Set toPurgeChecked; + /** + * Subset of toPurgeChecked. Marks primitives that remain in the + * dataset, but incomplete. + */ + protected Set makeIncomplete; + /** + * Subset of toPurgeChecked. Those that have not been in the selection. + */ + protected List toPurgeAdditionally; + + @Override + public void actionPerformed(ActionEvent e) { + if (!isEnabled()) + return; + + Collection sel = getCurrentDataSet().getSelected(); + layer = Main.map.mapView.getEditLayer(); + + toPurge = new HashSet(sel); + toPurgeAdditionally = new ArrayList(); + toPurgeChecked = new HashSet(); + + // Add referrer, unless the object to purge is not new + // and the parent is a relation + while (!toPurge.isEmpty()) { + OsmPrimitive osm = toPurge.iterator().next(); + for (OsmPrimitive parent: osm.getReferrers()) { + if (toPurge.contains(parent) || toPurgeChecked.contains(parent)) + continue; + if (parent instanceof Way || (parent instanceof Relation && osm.isNew())) { + toPurgeAdditionally.add(parent); + toPurge.add(parent); + } + } + toPurge.remove(osm); + toPurgeChecked.add(osm); + } + + makeIncomplete = new HashSet(); + + // Find the objects that will be incomplete after purging. + // At this point, all parents of new to-be-purged primitives are + // also to-be-purged and + // all parents of not-new to-be-purged primitives are either + // to-be-purged or of type relation. + TOP: + for (OsmPrimitive child : toPurgeChecked) { + if (child.isNew()) + continue; + for (OsmPrimitive parent : child.getReferrers()) { + if (parent instanceof Relation && !toPurgeChecked.contains(parent)) { + makeIncomplete.add(child); + continue TOP; + } + } + } + + // Add untagged way nodes. Do not add nodes that have other + // referrers not yet to-be-purged. + if (Main.pref.getBoolean("purge.add_untagged_waynodes", true)) { + Set wayNodes = new HashSet(); + for (OsmPrimitive osm : toPurgeChecked) { + if (osm instanceof Way) { + Way w = (Way) osm; + NODE: + for (Node n : w.getNodes()) { + if (n.isTagged() || toPurgeChecked.contains(n)) + continue; + for (OsmPrimitive ref : n.getReferrers()) { + if (ref != w && !toPurgeChecked.contains(ref)) + continue NODE; + } + wayNodes.add(n); + } + } + } + toPurgeChecked.addAll(wayNodes); + toPurgeAdditionally.addAll(wayNodes); + } + + boolean modified = false; + for (OsmPrimitive osm : toPurgeChecked) { + if (osm.isModified()) { + modified = true; + break; + } + } + + ExtendedDialog confirmDlg = new ExtendedDialog(Main.parent, tr("Confirm Purging"), new String[] {tr("Purge"), tr("Cancel")}); + confirmDlg.setContent(buildPanel(modified), false); + confirmDlg.setButtonIcons(new String[] {"ok", "cancel"}); + + int answer = confirmDlg.showDialog().getValue(); + if (answer != 1) + return; + + Main.pref.put("purge.clear_undo_redo", cbClearUndoRedo.isSelected()); + + Main.main.undoRedo.add(new PurgeCommand(Main.map.mapView.getEditLayer(), toPurgeChecked, makeIncomplete)); + + if (cbClearUndoRedo.isSelected()) { + Main.main.undoRedo.clean(); + } + } + + private JPanel buildPanel(boolean modified) { + JPanel pnl = new JPanel(new GridBagLayout()); + + pnl.add(Box.createRigidArea(new Dimension(400,0)), GBC.eol().fill(GBC.HORIZONTAL)); + + pnl.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); + pnl.add(new JLabel(""+ + tr("This operation makes JOSM forget the selected objects.
" + + "They will be removed from the layer, but not deleted
" + + "on the server when uploading.")+"", + ImageProvider.get("purge"), JLabel.LEFT), GBC.eol().fill(GBC.HORIZONTAL)); + + if (!toPurgeAdditionally.isEmpty()) { + pnl.add(new JSeparator(), GBC.eol().fill(GBC.HORIZONTAL).insets(0,5,0,5)); + pnl.add(new JLabel(""+ + tr("The following dependent objects will be purged
" + + "in addition to the selected objects:")+"", + ImageProvider.get("warning-small"), JLabel.LEFT), GBC.eol().fill(GBC.HORIZONTAL)); + + Collections.sort(toPurgeAdditionally, new Comparator() { + public int compare(OsmPrimitive o1, OsmPrimitive o2) { + int type = o1.getType().compareTo(o2.getType()); + if (type != 0) + return -type; + return (new Long(o1.getUniqueId())).compareTo(o2.getUniqueId()); + } + }); + JList list = new JList(toPurgeAdditionally.toArray(new OsmPrimitive[0])); + /* force selection to be active for all entries */ + list.setCellRenderer(new OsmPrimitivRenderer() { + @Override + public Component getListCellRendererComponent(JList list, + Object value, + int index, + boolean isSelected, + boolean cellHasFocus) { + return super.getListCellRendererComponent(list, value, index, true, false); + } + }); + JScrollPane scroll = new JScrollPane(list); + scroll.setPreferredSize(new Dimension(250, 300)); + scroll.setMinimumSize(new Dimension(250, 300)); + pnl.add(scroll, GBC.std().fill(GBC.VERTICAL).weight(0.0, 1.0)); + + JButton addToSelection = new JButton(new AbstractAction() { + { + putValue(SHORT_DESCRIPTION, tr("Add to selection")); + putValue(SMALL_ICON, ImageProvider.get("dialogs","select")); + } + + public void actionPerformed(ActionEvent e) { + layer.data.addSelected(toPurgeAdditionally); + } + }); + addToSelection.setMargin(new Insets(0,0,0,0)); + pnl.add(addToSelection, GBC.eol().anchor(GBC.SOUTHWEST).weight(1.0, 1.0).insets(2,0,0,3)); + } + + if (modified) { + pnl.add(new JSeparator(), GBC.eol().fill(GBC.HORIZONTAL).insets(0,5,0,5)); + pnl.add(new JLabel(""+tr("Some of the objects are modified.
" + + "Proceed, if these changes should be discarded."+""), + ImageProvider.get("warning-small"), JLabel.LEFT), + GBC.eol().fill(GBC.HORIZONTAL)); + } + + cbClearUndoRedo = new JCheckBox(tr("Clear Undo/Redo buffer")); + cbClearUndoRedo.setSelected(Main.pref.getBoolean("purge.clear_undo_redo", false)); + + pnl.add(new JSeparator(), GBC.eol().fill(GBC.HORIZONTAL).insets(0,5,0,5)); + pnl.add(cbClearUndoRedo, GBC.eol()); + return pnl; + } + + @Override + protected void updateEnabledState() { + if (getCurrentDataSet() == null) { + setEnabled(false); + } else { + setEnabled(!(getCurrentDataSet().selectionEmpty())); + } + } + + @Override + protected void updateEnabledState(Collection selection) { + setEnabled(selection != null && !selection.isEmpty()); + } +} Index: trunk/src/org/openstreetmap/josm/command/DeleteCommand.java =================================================================== --- trunk/src/org/openstreetmap/josm/command/DeleteCommand.java (revision 3430) +++ trunk/src/org/openstreetmap/josm/command/DeleteCommand.java (revision 3431) @@ -488,5 +488,5 @@ tr("You are about to delete incomplete objects." + "
" - + "This will cause problems because you don't see the real object." + + "This will cause problems because you don''t see the real object." + "
" + "Do you really want to delete?") + "")); boolean answer = ConditionalOptionPaneUtil.showConfirmationDialog( Index: trunk/src/org/openstreetmap/josm/command/PurgeCommand.java =================================================================== --- trunk/src/org/openstreetmap/josm/command/PurgeCommand.java (revision 3431) +++ trunk/src/org/openstreetmap/josm/command/PurgeCommand.java (revision 3431) @@ -0,0 +1,265 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.command; + +import static org.openstreetmap.josm.tools.I18n.trn; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.swing.JLabel; + +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.data.osm.Hash; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.NodeData; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.PrimitiveData; +import org.openstreetmap.josm.data.osm.PrimitiveId; +import org.openstreetmap.josm.data.osm.Relation; +import org.openstreetmap.josm.data.osm.RelationData; +import org.openstreetmap.josm.data.osm.Storage; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.osm.WayData; +import org.openstreetmap.josm.gui.layer.OsmDataLayer; +import org.openstreetmap.josm.tools.ImageProvider; + +/** + * Command, to purge a list of primitives. + */ +public class PurgeCommand extends Command { + protected List toPurge; + protected Storage makeIncompleteData; + + protected Map makeIncompleteData_byPrimId; + + final protected DataSet ds; + + /** + * This command relies on a number of consistency conditions: + * - makeIncomplete must be a subset of toPurge. + * - Each primitive, that is in toPurge but not in makeIncomplete, must + * have all its referrers in toPurge. + * - Each element of makeIncomplete must not be new and must have only + * referrers that are either a relation or included in toPurge. + */ + public PurgeCommand(OsmDataLayer layer, Collection toPurge, Collection makeIncomplete) { + super(layer); + this.ds = layer.data; + /** + * The topological sort is to avoid missing way nodes and missing + * relation members when adding primitives back to the dataset on undo. + * + * The same should hold for normal execution, but at time of writing + * there seem to be no such consistency checks when removing primitives. + * (It is done in a save manner, anyway.) + */ + this.toPurge = topoSort(toPurge); + saveIncomplete(makeIncomplete); + } + + protected void saveIncomplete(Collection makeIncomplete) { + makeIncompleteData = new Storage(new Hash() { + public int getHashCode(PrimitiveData k) { + return (int) k.getUniqueId(); + } + + public boolean equals(PrimitiveData k, PrimitiveData t) { + return k.getUniqueId() == t.getUniqueId() && k.getType() == t.getType(); + } + }); + makeIncompleteData_byPrimId = makeIncompleteData.foreignKey(new Hash() { + public int getHashCode(PrimitiveId k) { + return (int) k.getUniqueId(); + } + + public boolean equals(PrimitiveId k, PrimitiveData t) { + return k.getUniqueId() == t.getUniqueId() && k.getType() == t.getType(); + } + }); + + for (OsmPrimitive osm : makeIncomplete) { + makeIncompleteData.add(osm.save()); + } + } + + @Override + public boolean executeCommand() { + ds.beginUpdate(); + try { + /** + * Loop from back to front to keep referential integrity. + */ + for (int i=toPurge.size()-1; i>=0; --i) { + OsmPrimitive osm = toPurge.get(i); + if (makeIncompleteData_byPrimId.containsKey(osm)) { + // we could simply set the incomplete flag + // but that would not free memory in case the + // user clears undo/redo buffer after purge + PrimitiveData empty; + switch(osm.getType()) { + case NODE: empty = new NodeData(); break; + case WAY: empty = new WayData(); break; + case RELATION: empty = new RelationData(); break; + default: throw new AssertionError(); + } + empty.setId(osm.getUniqueId()); + empty.setIncomplete(true); + osm.load(empty); + } else { + ds.removePrimitive(osm); + } + } + } finally { + ds.endUpdate(); + } + return true; + } + + @Override + public void undoCommand() { + if (ds == null) + return; + + for (OsmPrimitive osm : toPurge) { + PrimitiveData data = makeIncompleteData_byPrimId.get(osm); + if (data != null) { + if (ds.getPrimitiveById(osm) != osm) + throw new AssertionError(String.format("Primitive %s has been made incomplete when purging, but it cannot be found on undo.", osm)); + osm.load(data); + } else { + if (ds.getPrimitiveById(osm) != null) + throw new AssertionError(String.format("Primitive %s was removed when purging, but is still there on undo", osm)); + ds.addPrimitive(osm); + } + } + } + + /** + * Sorts a collection of primitives such that for each object + * its referrers come later in the sorted collection. + */ + public static List topoSort(Collection sel) { + Set in = new HashSet(sel); + + List out = new ArrayList(in.size()); + + /** + * First add nodes that have no way referrer. + */ + outer: + for (Iterator it = in.iterator(); it.hasNext();) { + OsmPrimitive u = it.next(); + if (u instanceof Node) { + Node n = (Node) u; + for (OsmPrimitive ref : n.getReferrers()) { + if (ref instanceof Way && in.contains(ref)) + continue outer; + } + it.remove(); + out.add(n); + } + } + + /** + * Then add all ways, each preceded by its (remaining) nodes. + */ + top: + while (!in.isEmpty()) { + for (Iterator it = in.iterator(); it.hasNext();) { + OsmPrimitive u = it.next(); + if (u instanceof Way) { + Way w = (Way) u; + it.remove(); + for (Node n : w.getNodes()) { + if (in.contains(n)) { + in.remove(n); + out.add(n); + } + } + out.add(w); + continue top; + } + } + break; // no more ways left + } + + /** + * Rest are relations. Do topological sorting on a DAG where each + * arrow points from child to parent. (Because it is faster to + * loop over getReferrers() than getMembers().) + */ + Set inR = (Set) in; + Set childlessR = new HashSet(); + List outR = new ArrayList(inR.size()); + + HashMap numChilds = new HashMap(); + + // calculate initial number of childs + for (Relation r : inR) { + numChilds.put(r, 0); + } + for (Relation r : inR) { + for (OsmPrimitive parent : r.getReferrers()) { + if (!(parent instanceof Relation)) + throw new AssertionError(); + Integer i = numChilds.get((Relation)parent); + if (i != null) { + numChilds.put((Relation)parent, i+1); + } + } + } + for (Relation r : inR) { + if (numChilds.get(r).equals(0)) { + childlessR.add(r); + } + } + + while (!childlessR.isEmpty()) { + // Identify one childless Relation and + // let it virtually die. This makes other + // relations childless. + Iterator it = childlessR.iterator(); + Relation next = it.next(); + it.remove(); + outR.add(next); + + for (OsmPrimitive parentPrim : next.getReferrers()) { + Relation parent = (Relation) parentPrim; + Integer i = numChilds.get(parent); + if (i != null) { + numChilds.put(parent, i-1); + if (i-1 == 0) { + childlessR.add(parent); + } + } + } + } + + if (outR.size() != inR.size()) + throw new AssertionError("topo sort algorithm failed"); + + out.addAll(outR); + + return out; + } + + @Override + public Object getDescription() { + return new JLabel(trn("Purged {0} object", "Purged {0} objects", toPurge.size(), toPurge.size()), ImageProvider.get("data", "purge"), JLabel.HORIZONTAL); + } + + @Override + public Collection getParticipatingPrimitives() { + return toPurge; + } + + @Override + public void fillModifiedData(Collection modified, Collection deleted, Collection added) { + } +} Index: trunk/src/org/openstreetmap/josm/data/osm/DataSet.java =================================================================== --- trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 3430) +++ trunk/src/org/openstreetmap/josm/data/osm/DataSet.java (revision 3431) @@ -399,4 +399,11 @@ } + /** + * @return whether the selection is empty or not + */ + public boolean selectionEmpty() { + return selectedPrimitives.isEmpty(); + } + public boolean isSelected(OsmPrimitive osm) { return selectedPrimitives.contains(osm); Index: trunk/src/org/openstreetmap/josm/gui/MainApplication.java =================================================================== --- trunk/src/org/openstreetmap/josm/gui/MainApplication.java (revision 3430) +++ trunk/src/org/openstreetmap/josm/gui/MainApplication.java (revision 3431) @@ -256,4 +256,5 @@ dialog.setContent(tr("JOSM found {0} unsaved osm data layers. It looks like JOSM crashed last time. Do you want to restore data?", unsavedLayers.size())); + dialog.setIcon(JOptionPane.INFORMATION_MESSAGE); dialog.setButtonIcons(new String[] {"ok.png", "cancel.png"}); dialog.showDialog(); @@ -299,5 +300,6 @@ String version = System.getProperty("java.version"); if (version != null) { - if (version.startsWith("1.6") || version.startsWith("6")) + if (version.startsWith("1.6") || version.startsWith("6") || + version.startsWith("1.7") || version.startsWith("7")) return; if (version.startsWith("1.5") || version.startsWith("5")) { Index: trunk/src/org/openstreetmap/josm/gui/MainMenu.java =================================================================== --- trunk/src/org/openstreetmap/josm/gui/MainMenu.java (revision 3430) +++ trunk/src/org/openstreetmap/josm/gui/MainMenu.java (revision 3431) @@ -55,4 +55,5 @@ import org.openstreetmap.josm.actions.PasteTagsAction; import org.openstreetmap.josm.actions.PreferencesAction; +import org.openstreetmap.josm.actions.PurgeAction; import org.openstreetmap.josm.actions.RedoAction; import org.openstreetmap.josm.actions.ReverseWayAction; @@ -123,4 +124,5 @@ public final JosmAction duplicate = new DuplicateAction(); public final JosmAction delete = new DeleteAction(); + public final JosmAction purge = new PurgeAction(); public final JosmAction merge = new MergeLayerAction(); public final JosmAction mergeSelected = new MergeSelectionAction(); @@ -247,4 +249,5 @@ add(editMenu, duplicate); add(editMenu, delete); + add(editMenu, purge); editMenu.addSeparator(); add(editMenu,merge); Index: trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java =================================================================== --- trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java (revision 3430) +++ trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java (revision 3431) @@ -1101,7 +1101,9 @@ putValue(NAME, tr("Select relation")); putValue(SHORT_DESCRIPTION, tr("Select relation in main selection.")); + putValue(SMALL_ICON, ImageProvider.get("dialogs", "select")); } else { putValue(NAME, tr("Select in relation list")); putValue(SHORT_DESCRIPTION, tr("Select relation in relation list.")); + putValue(SMALL_ICON, ImageProvider.get("dialogs", "relationlist")); } }