Changeset 2008 in josm for trunk/src/org/openstreetmap/josm/actions/PasteTagsAction.java

Timestamp:

2009-08-30T15:41:28+02:00 (15 years ago)

Author:

Gubaer

Message:

new: tag conflict resolution when pasting tags (only if necessary)
fixed #2611: cant copy'n'past tags from a relation to ways or other way round
fixed #3137: Paste Tags does not work for relations

File:

• trunk/src/org/openstreetmap/josm/actions/PasteTagsAction.java (modified) (5 diffs)

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

@@ -4 +4 @@
 
 import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trn;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 
@@ -18 +19 @@
 import org.openstreetmap.josm.command.SequenceCommand;
 import org.openstreetmap.josm.data.osm.DataSet;
-import org.openstreetmap.josm.data.osm.DataSource;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.TagCollection;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.conflict.tags.PasteTagsConflictResolverDialog;
 import org.openstreetmap.josm.tools.Shortcut;
 
@@ -31 +37 @@
     }
 
-    private void pasteKeys(Collection<Command> clist, Collection<? extends OsmPrimitive> pasteBufferSubset, Collection<OsmPrimitive> selectionSubset) {
-        /* scan the paste buffer, and add tags to each of the selected objects.
-         * If a tag already exists, it is overwritten */
-        if (selectionSubset == null || selectionSubset.isEmpty())
+    /**
+     * Replies true if the source for tag pasting is heterogeneous, i.e. if it doesn't consist of
+     * {@see OsmPrimitive}s of exactly one type
+     * 
+     * @return
+     */
+    protected boolean isHeteogeneousSource() {
+        int count = 0;
+        count = !getSourcePrimitivesByType(Node.class).isEmpty() ? count + 1 : count;
+        count = !getSourcePrimitivesByType(Way.class).isEmpty() ? count + 1 : count;
+        count = !getSourcePrimitivesByType(Relation.class).isEmpty() ? count + 1 : count;
+        return count > 1;
+    }
+
+    /**
+     * Replies the subset  of {@see OsmPrimitive}s of <code>type</code> from <code>superSet</code>.
+     * 
+     * @param <T>
+     * @param superSet  the super set of primitives
+     * @param type  the type
+     * @return
+     */
+    protected <T extends OsmPrimitive> Collection<? extends OsmPrimitive> getSubcollectionByType(Collection<? extends OsmPrimitive> superSet, Class<T> type) {
+        Collection<OsmPrimitive> ret = new ArrayList<OsmPrimitive>();
+        for (OsmPrimitive p : superSet) {
+            if (type.isInstance(p)) {
+                ret.add(p);
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Replies all primitives of type <code>type</code> in the current selection.
+     * 
+     * @param <T>
+     * @param type  the type
+     * @return all primitives of type <code>type</code> in the current selection.
+     */
+    protected <T extends OsmPrimitive> Collection<? extends OsmPrimitive> getSourcePrimitivesByType(Class<T> type) {
+        return getSubcollectionByType(Main.pasteBuffer.getSelected(), type);
+    }
+
+    /**
+     * Replies the collection of tags for all primitives of type <code>type</code> in the current
+     * selection
+     * 
+     * @param <T>
+     * @param type  the type
+     * @return the collection of tags for all primitives of type <code>type</code> in the current
+     * selection
+     */
+    protected <T extends OsmPrimitive> TagCollection getSourceTagsByType(Class<T> type) {
+        return TagCollection.unionOfAllPrimitives(getSourcePrimitivesByType(type));
+    }
+
+    /**
+     * Replies true if there is at least one tag in the current selection for primitives of
+     * type <code>type</code>
+     * 
+     * @param <T>
+     * @param type the type
+     * @return true if there is at least one tag in the current selection for primitives of
+     * type <code>type</code>
+     */
+    protected <T extends OsmPrimitive> boolean hasSourceTagsByType(Class<T> type) {
+        return ! getSourceTagsByType(type).isEmpty();
+    }
+
+    protected Command buildChangeCommand(Collection<? extends OsmPrimitive> selection, TagCollection tc) {
+        List<Command> commands = new ArrayList<Command>();
+        for (String key : tc.getKeys()) {
+            String value = tc.getValues(key).iterator().next();
+            value = value.equals("") ? null : value;
+            commands.add(new ChangePropertyCommand(selection,key,value));
+        }
+        if (!commands.isEmpty()) {
+            String title1 = trn("Pasting {0} tag", "Pasting {0} tags", tc.getKeys().size(), tc.getKeys().size());
+            String title2 = trn("to {0} primitive", "to {0} primtives", selection.size(), selection.size());
+            return new SequenceCommand(
+                    title1 + " " + title2,
+                    commands
+            );
+        }
+        return null;
+    }
+
+    protected Map<OsmPrimitiveType, Integer> getSourceStatistics() {
+        HashMap<OsmPrimitiveType, Integer> ret = new HashMap<OsmPrimitiveType, Integer>();
+        for (Class type: new Class[] {Node.class, Way.class, Relation.class}) {
+            if (!getSourceTagsByType(type).isEmpty()) {
+                ret.put(OsmPrimitiveType.from(type), getSourcePrimitivesByType(type).size());
+            }
+        }
+        return ret;
+    }
+
+    protected Map<OsmPrimitiveType, Integer> getTargetStatistics() {
+        HashMap<OsmPrimitiveType, Integer> ret = new HashMap<OsmPrimitiveType, Integer>();
+        for (Class type: new Class[] {Node.class, Way.class, Relation.class}) {
+            int count = getSubcollectionByType(getEditLayer().data.getSelected(), type).size();
+            if (count > 0) {
+                ret.put(OsmPrimitiveType.from(type), count);
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Pastes the tags from a homogeneous source (i.e. the {@see Main#pasteBuffer}s selection consisting
+     * of one type of {@see OsmPrimitive}s only.
+     * 
+     * Tags from a homogeneous source can be pasted to a heterogeneous target. All target primitives,
+     * regardless of their type, receive the same tags.
+     * 
+     * @param targets the collection of target primitives
+     */
+    protected void pasteFromHomogeneousSource(Collection<? extends OsmPrimitive> targets) {
+        TagCollection tc = null;
+        Class sourceType = null;
+        for (Class type : new Class[] {Node.class, Way.class, Relation.class}) {
+            TagCollection tc1 = getSourceTagsByType(type);
+            if (!tc1.isEmpty()) {
+                tc = tc1;
+                sourceType = type;
+            }
+        }
+        if (tc == null)
+            // no tags found to paste. Abort.
             return;
 
-        for (Iterator<? extends OsmPrimitive> it = pasteBufferSubset.iterator(); it.hasNext();) {
-            OsmPrimitive osm = it.next();
-
-            for (String key : osm.keySet()) {
-                clist.add(new ChangePropertyCommand(selectionSubset, key, osm.get(key)));
+
+        if (!tc.isApplicableToPrimitive()) {
+            PasteTagsConflictResolverDialog dialog = new PasteTagsConflictResolverDialog(Main.parent);
+            dialog.populate(tc, getSourceStatistics(), getTargetStatistics());
+            dialog.setVisible(true);
+            if (dialog.isCanceled())
+                return;
+            Command cmd = buildChangeCommand(targets, dialog.getResolution());
+            Main.main.undoRedo.add(cmd);
+        } else {
+            // no conflicts in the source tags to resolve. Just apply the tags
+            // to the target primitives
+            //
+            Command cmd = buildChangeCommand(targets, tc);
+            Main.main.undoRedo.add(cmd);
+        }
+    }
+
+    /**
+     * Replies true if there is at least one primitive of type <code>type</code> in the collection
+     * <code>selection</code>
+     * 
+     * @param <T>
+     * @param selection  the collection of primitives
+     * @param type  the type to look for
+     * @return true if there is at least one primitive of type <code>type</code> in the collection
+     * <code>selection</code>
+     */
+    protected <T extends OsmPrimitive> boolean hasTargetPrimitives(Collection<? extends OsmPrimitive> selection, Class<T> type) {
+        return !getSubcollectionByType(selection, type).isEmpty();
+    }
+
+    /**
+     * Replies true if this a heterogeneous source can be pasted without conflict to targets
+     * 
+     * @param targets the collection of target primitives
+     * @return true if this a heterogeneous source can be pasted without conflicts to targets
+     */
+    protected boolean canPasteFromHeterogeneousSourceWithoutConflict(Collection<? extends OsmPrimitive> targets) {
+        if (hasTargetPrimitives(targets, Node.class)) {
+            TagCollection tc = TagCollection.unionOfAllPrimitives(getSourcePrimitivesByType(Node.class));
+            if (!tc.isEmpty() && ! tc.isApplicableToPrimitive())
+                return false;
+        }
+        if (hasTargetPrimitives(targets, Way.class)) {
+            TagCollection tc = TagCollection.unionOfAllPrimitives(getSourcePrimitivesByType(Way.class));
+            if (!tc.isEmpty() && ! tc.isApplicableToPrimitive())
+                return false;
+        }
+        if (hasTargetPrimitives(targets, Relation.class)) {
+            TagCollection tc = TagCollection.unionOfAllPrimitives(getSourcePrimitivesByType(Relation.class));
+            if (!tc.isEmpty() && ! tc.isApplicableToPrimitive())
+                return false;
+        }
+        return true;
+    }
+
+    /**
+     * Pastes the tags in the current selection of the paste buffer to a set of target
+     * primitives.
+     * 
+     * @param targets the collection of target primitives
+     */
+    protected void pasteFromHeterogeneousSource(Collection<? extends OsmPrimitive> targets) {
+        if (canPasteFromHeterogeneousSourceWithoutConflict(targets)) {
+            if (hasSourceTagsByType(Node.class) && hasTargetPrimitives(targets, Node.class)) {
+                Command cmd = buildChangeCommand(targets, getSourceTagsByType(Node.class));
+                Main.main.undoRedo.add(cmd);
+            }
+            if (hasSourceTagsByType(Way.class) && hasTargetPrimitives(targets, Way.class)) {
+                Command cmd = buildChangeCommand(targets, getSourceTagsByType(Way.class));
+                Main.main.undoRedo.add(cmd);
+            }
+            if (hasSourceTagsByType(Relation.class) && hasTargetPrimitives(targets, Relation.class)) {
+                Command cmd = buildChangeCommand(targets,getSourceTagsByType(Relation.class));
+                Main.main.undoRedo.add(cmd);
+            }
+        } else {
+            PasteTagsConflictResolverDialog dialog = new PasteTagsConflictResolverDialog(Main.parent);
+            dialog.populate(
+                    getSourceTagsByType(Node.class),
+                    getSourceTagsByType(Way.class),
+                    getSourceTagsByType(Relation.class),
+                    getSourceStatistics(),
+                    getTargetStatistics()
+            );
+            dialog.setVisible(true);
+            if (dialog.isCanceled())
+                return;
+            if (hasSourceTagsByType(Node.class) && hasTargetPrimitives(targets, Node.class)) {
+                Command cmd = buildChangeCommand(getSubcollectionByType(targets, Node.class), dialog.getResolution(OsmPrimitiveType.NODE));
+                Main.main.undoRedo.add(cmd);
+            }
+            if (hasSourceTagsByType(Way.class) && hasTargetPrimitives(targets, Way.class)) {
+                Command cmd = buildChangeCommand(getSubcollectionByType(targets, Way.class), dialog.getResolution(OsmPrimitiveType.WAY));
+                Main.main.undoRedo.add(cmd);
+            }
+            if (hasSourceTagsByType(Relation.class) && hasTargetPrimitives(targets, Relation.class)) {
+                Command cmd = buildChangeCommand(getSubcollectionByType(targets, Relation.class), dialog.getResolution(OsmPrimitiveType.RELATION));
+                Main.main.undoRedo.add(cmd);
             }
         }
@@ -47 +273 @@
 
     public void actionPerformed(ActionEvent e) {
-        Collection<Command> clist = new LinkedList<Command>();
-        String pbSource = "Multiple Sources";
-        if(Main.pasteBuffer.dataSources.size() == 1) {
-            pbSource = ((DataSource) Main.pasteBuffer.dataSources.toArray()[0]).origin;
-        }
-
-        boolean pbNodes = Main.pasteBuffer.nodes.size() > 0;
-        boolean pbWays  = Main.pasteBuffer.ways.size() > 0;
-
-        boolean seNodes = getCurrentDataSet().getSelectedNodes().size() > 0;
-        boolean seWays  = getCurrentDataSet().getSelectedWays().size() > 0;
-        boolean seRels  = getCurrentDataSet().getSelectedRelations().size() > 0;
-
-        if(!seNodes && seWays && !seRels && pbNodes && pbSource.equals("Copied Nodes")) {
-            // Copy from nodes to ways
-            pasteKeys(clist, Main.pasteBuffer.nodes, getCurrentDataSet().getSelectedWays());
-        } else if(seNodes && !seWays && !seRels && pbWays && pbSource.equals("Copied Ways")) {
-            // Copy from ways to nodes
-            pasteKeys(clist, Main.pasteBuffer.ways, getCurrentDataSet().getSelectedNodes());
+        if (getCurrentDataSet().getSelected().isEmpty())
+            return;
+        if (isHeteogeneousSource()) {
+            pasteFromHeterogeneousSource(getCurrentDataSet().getSelected());
         } else {
-            // Copy from equal to equal
-            pasteKeys(clist, Main.pasteBuffer.nodes, getCurrentDataSet().getSelectedNodes());
-            pasteKeys(clist, Main.pasteBuffer.ways, getCurrentDataSet().getSelectedWays());
-            pasteKeys(clist, Main.pasteBuffer.relations, getCurrentDataSet().getSelectedRelations());
-        }
-        Main.main.undoRedo.add(new SequenceCommand(tr("Paste Tags"), clist));
-        getCurrentDataSet().setSelected(getCurrentDataSet().getSelected()); // to force selection listeners, in particular the tag panel, to update
-        Main.map.mapView.repaint();
-    }
-
-    private boolean containsSameKeysWithDifferentValues(Collection<? extends OsmPrimitive> osms) {
-        Map<String,String> kvSeen = new HashMap<String,String>();
-        for (OsmPrimitive osm:osms) {
-            for (String key : osm.keySet()) {
-                String value = osm.get(key);
-                if (! kvSeen.containsKey(key)) {
-                    kvSeen.put(key, value);
-                } else if (! kvSeen.get(key).equals(value))
-                    return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Determines whether to enable the widget depending on the contents of the paste
-     * buffer and current selection
-     * @param pasteBuffer
-     */
-    private void possiblyEnable(Collection<? extends OsmPrimitive> selection, DataSet pasteBuffer) {
-        /* only enable if there is something selected to paste into and
-            if we don't have conflicting keys in the pastebuffer */
-        DataSet ds = getCurrentDataSet();
-        if (ds == null || ds.getSelected().isEmpty() || pasteBuffer == null || pasteBuffer.allPrimitives().isEmpty()) {
-            setEnabled(false);
-            return;
-        }
-        setEnabled((!ds.getSelectedNodes().isEmpty() && ! containsSameKeysWithDifferentValues(pasteBuffer.nodes)) ||
-                (!ds.getSelectedWays().isEmpty() && ! containsSameKeysWithDifferentValues(pasteBuffer.ways)) ||
-                (! ds.getSelectedRelations().isEmpty() && ! containsSameKeysWithDifferentValues(pasteBuffer.relations)));
+            pasteFromHomogeneousSource(getCurrentDataSet().getSelected());
+        }
     }
 
@@ -119 +292 @@
             return;
         }
-        possiblyEnable(getCurrentDataSet().getSelected(), Main.pasteBuffer);
+        setEnabled(
+                !getCurrentDataSet().getSelected().isEmpty()
+                && !TagCollection.unionOfAllPrimitives(Main.pasteBuffer.getSelected()).isEmpty()
+        );
     }
 }