diff --git a/src/org/openstreetmap/josm/data/validation/tests/UntaggedNode.java b/src/org/openstreetmap/josm/data/validation/tests/UntaggedNode.java
index d6eb236..0ee9003 100644
--- a/src/org/openstreetmap/josm/data/validation/tests/UntaggedNode.java
+++ b/src/org/openstreetmap/josm/data/validation/tests/UntaggedNode.java
@@ -5,6 +5,8 @@ import static org.openstreetmap.josm.tools.I18n.marktr;
 import static org.openstreetmap.josm.tools.I18n.tr;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.Map;
 
 import org.openstreetmap.josm.Main;
@@ -15,7 +17,6 @@ import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.validation.Severity;
 import org.openstreetmap.josm.data.validation.Test;
 import org.openstreetmap.josm.data.validation.TestError;
-import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 
 /**
  * Checks for nodes with uninteresting tags that are in no way
@@ -41,11 +42,6 @@ public class UntaggedNode extends Test {
     }
 
     @Override
-    public void startTest(ProgressMonitor monitor) {
-        super.startTest(monitor);
-    }
-
-    @Override
     public void visit(Collection<OsmPrimitive> selection) {
         for (OsmPrimitive p : selection) {
             if (p.isUsable() && p instanceof Node) {
@@ -54,12 +50,14 @@ public class UntaggedNode extends Test {
         }
     }
 
+    Map<Integer,TestError> fixableErrors = new HashMap<Integer, TestError>();
+
     @Override
     public void visit(Node n) {
-        if(n.isUsable() && !n.isTagged() && n.getReferrers().isEmpty()) {
+        if (n.isUsable() && !n.isTagged() && n.getReferrers().isEmpty()
+                && Main.main.getCurrentDataSet().getDataSourceArea().contains(n.getCoor())) {
             if (!n.hasKeys()) {
-                String msg = marktr("No tags");
-                errors.add(new TestError(this, Severity.WARNING, tr("Unconnected nodes without physical tags"), tr(msg), msg, UNTAGGED_NODE_BLANK, n));
+                addError(marktr("No tags"), UNTAGGED_NODE_BLANK, n);
                 return;
             }
             for (Map.Entry<String, String> tag : n.getKeys().entrySet()) {
@@ -67,44 +65,56 @@ public class UntaggedNode extends Test {
                 if (contains(tag, "fixme") || contains(tag, "FIXME")) {
                     /* translation note: don't translate quoted words */
                     String msg = marktr("Has tag containing ''fixme'' or ''FIXME''");
-                    errors.add(new TestError(this, Severity.WARNING, tr("Unconnected nodes without physical tags"),
-                            tr(msg), msg, UNTAGGED_NODE_FIXME, n));
+                    addError(msg, UNTAGGED_NODE_FIXME, n);
                     return;
                 }
 
-                String msg = null;
-                int code = 0;
                 if (key.startsWith("note") || key.startsWith("comment") || key.startsWith("description")) {
                     /* translation note: don't translate quoted words */
-                    msg = marktr("Has key ''note'' or ''comment'' or ''description''");
-                    code = UNTAGGED_NODE_NOTE;
+                    String msg = marktr("Has key ''note'' or ''comment'' or ''description''");
+                    addError(msg, UNTAGGED_NODE_NOTE, n);
+                    return;
                 } else if (key.startsWith("created_by") || key.startsWith("converted_by")) {
                     /* translation note: don't translate quoted words */
-                    msg = marktr("Has key ''created_by'' or ''converted_by''");
-                    code = UNTAGGED_NODE_CREATED_BY;
+                    String msg = marktr("Has key ''created_by'' or ''converted_by''");
+                    addError(msg, UNTAGGED_NODE_CREATED_BY, n);
+                    return;
                 } else if (key.startsWith("watch")) {
                     /* translation note: don't translate quoted words */
-                    msg = marktr("Has key ''watch''");
-                    code = UNTAGGED_NODE_WATCH;
+                    String msg = marktr("Has key ''watch''");
+                    addError(msg, UNTAGGED_NODE_WATCH, n);
+                    return;
                 } else if (key.startsWith("source")) {
                     /* translation note: don't translate quoted words */
-                    msg = marktr("Has key ''source''");
-                    code = UNTAGGED_NODE_SOURCE;
-                }
-                if (msg != null) {
-                    errors.add(new TestError(this, Severity.WARNING, tr("Unconnected nodes without physical tags"),
-                            tr(msg), msg, code, n));
+                    String msg = marktr("Has key ''source''");
+                    addError(msg, UNTAGGED_NODE_SOURCE, n);
                     return;
                 }
             }
             // Does not happen, but just to be sure. Maybe definition of uninteresting tags changes in future.
-            errors.add(new TestError(this, Severity.WARNING, tr("Unconnected nodes without physical tags"),
-                    tr("Other"), "Other", UNTAGGED_NODE_OTHER, n));
+            addError(tr("Other"), UNTAGGED_NODE_OTHER, n);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void addError(String msg, int code, OsmPrimitive n) {
+        final String errMsg = tr("Unconnected nodes without physical tags");
+        if (!isFixable(code)) {
+            errors.add(new TestError(this, Severity.WARNING, errMsg, tr(msg), msg, code, n));
+        } else {
+            TestError err = fixableErrors.get(code);
+            if (err == null) {
+                err = new TestError(this, Severity.WARNING, errMsg, tr(msg), msg,
+                        code, new LinkedList<OsmPrimitive>());
+                fixableErrors.put(code, err);
+                errors.add(err);
+            }
+            ((Collection<OsmPrimitive>) err.getPrimitives()).add(n);
         }
     }
 
     private boolean contains(Map.Entry<String, String> tag, String s) {
-        return tag.getKey().indexOf(s) != -1 || tag.getValue().indexOf(s) != -1;
+        return tag.getKey().contains(s) || tag.getValue().contains(s);
     }
 
     @Override
@@ -115,15 +125,20 @@ public class UntaggedNode extends Test {
     @Override
     public boolean isFixable(TestError testError) {
         if (testError.getTester() instanceof UntaggedNode) {
-            int code = testError.getCode();
-            switch (code) {
+            return isFixable(testError.getCode());
+        }
+        return false;
+    }
+
+    private boolean isFixable(int code) {
+        switch (code) {
             case UNTAGGED_NODE_BLANK:
             case UNTAGGED_NODE_CREATED_BY:
             case UNTAGGED_NODE_WATCH:
             case UNTAGGED_NODE_SOURCE:
                 return true;
-            }
+            default:
+                return false;
         }
-        return false;
     }
 }