Index: trunk/src/org/openstreetmap/josm/corrector/CorrectionTable.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/CorrectionTable.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/CorrectionTable.java	(revision 1169)
@@ -13,50 +13,50 @@
         extends JTable {
 
-	private static final int MAX_VISIBLE_LINES = 10;
+    private static final int MAX_VISIBLE_LINES = 10;
 
     public static class BoldRenderer extends JLabel implements
-	        TableCellRenderer {
+            TableCellRenderer {
 
-		public Component getTableCellRendererComponent(JTable table,
-		        Object value, boolean isSelected, boolean hasFocus, int row,
-		        int column) {
+        public Component getTableCellRendererComponent(JTable table,
+                Object value, boolean isSelected, boolean hasFocus, int row,
+                int column) {
 
-			Font f = getFont();
-			setFont(new Font(f.getName(), f.getStyle() | Font.BOLD, f.getSize()));
+            Font f = getFont();
+            setFont(new Font(f.getName(), f.getStyle() | Font.BOLD, f.getSize()));
 
-			setText((String)value);
+            setText((String)value);
 
-			return this;
-		}
-	}
+            return this;
+        }
+    }
 
-	private static BoldRenderer boldRenderer = null;
+    private static BoldRenderer boldRenderer = null;
 
-	protected CorrectionTable(TM correctionTableModel) {
-		super(correctionTableModel);
+    protected CorrectionTable(TM correctionTableModel) {
+        super(correctionTableModel);
 
-		final int correctionsSize = correctionTableModel.getCorrections().size();
-		final int lines = correctionsSize > MAX_VISIBLE_LINES ? MAX_VISIBLE_LINES
+        final int correctionsSize = correctionTableModel.getCorrections().size();
+        final int lines = correctionsSize > MAX_VISIBLE_LINES ? MAX_VISIBLE_LINES
                 : correctionsSize;
-		setPreferredScrollableViewportSize(new Dimension(400, lines
-		        * getRowHeight()));
-		getColumnModel().getColumn(correctionTableModel.getApplyColumn())
+        setPreferredScrollableViewportSize(new Dimension(400, lines
+                * getRowHeight()));
+        getColumnModel().getColumn(correctionTableModel.getApplyColumn())
                 .setPreferredWidth(40);
-		setRowSelectionAllowed(false);
-	}
+        setRowSelectionAllowed(false);
+    }
 
-	public TableCellRenderer getCellRenderer(int row, int column) {
-		if (getCorrectionTableModel().isBoldCell(row, column)) {
-			if (boldRenderer == null)
-				boldRenderer = new BoldRenderer();
-			return boldRenderer;
-		}
-		return super.getCellRenderer(row, column);
-	}
+    public TableCellRenderer getCellRenderer(int row, int column) {
+        if (getCorrectionTableModel().isBoldCell(row, column)) {
+            if (boldRenderer == null)
+                boldRenderer = new BoldRenderer();
+            return boldRenderer;
+        }
+        return super.getCellRenderer(row, column);
+    }
 
-	@SuppressWarnings("unchecked")
+    @SuppressWarnings("unchecked")
     public TM getCorrectionTableModel() {
-		return (TM)getModel();
-	}
+        return (TM)getModel();
+    }
 
 }
Index: trunk/src/org/openstreetmap/josm/corrector/CorrectionTableModel.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/CorrectionTableModel.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/CorrectionTableModel.java	(revision 1169)
@@ -12,69 +12,69 @@
         AbstractTableModel {
 
-	private List<C> corrections;
-	private boolean[] apply;
-	private int applyColumn;
+    private List<C> corrections;
+    private boolean[] apply;
+    private int applyColumn;
 
-	public CorrectionTableModel(List<C> corrections) {
-		super();
-		this.corrections = corrections;
-		apply = new boolean[this.corrections.size()];
-		Arrays.fill(apply, true);
-		applyColumn = getColumnCount() - 1; 
-	}
-
-	abstract public int getColumnCount();
-
-	abstract protected boolean isBoldCell(int row, int column);
-	abstract public String getCorrectionColumnName(int colIndex);
-	abstract public Object getCorrectionValueAt(int rowIndex, int colIndex);
-
-	public List<C> getCorrections() {
-		return corrections;
-	}
-	
-	public int getApplyColumn() {
-		return applyColumn;
-	}
-	
-    public boolean getApply(int i) {
-    	return apply[i];
+    public CorrectionTableModel(List<C> corrections) {
+        super();
+        this.corrections = corrections;
+        apply = new boolean[this.corrections.size()];
+        Arrays.fill(apply, true);
+        applyColumn = getColumnCount() - 1;
     }
 
-	public int getRowCount() {
-    	return corrections.size();
+    abstract public int getColumnCount();
+
+    abstract protected boolean isBoldCell(int row, int column);
+    abstract public String getCorrectionColumnName(int colIndex);
+    abstract public Object getCorrectionValueAt(int rowIndex, int colIndex);
+
+    public List<C> getCorrections() {
+        return corrections;
     }
 
-	@Override
-    public Class<?> getColumnClass(int columnIndex) {
-    	if (columnIndex == applyColumn)
-    		return Boolean.class;
-    	return String.class;
+    public int getApplyColumn() {
+        return applyColumn;
     }
 
-	@Override
-	public String getColumnName(int columnIndex) {
-    	if (columnIndex == applyColumn)
-    		return tr("Apply?");
-		
-		return getCorrectionColumnName(columnIndex);
-	}
-
-	@Override
-    public boolean isCellEditable(int rowIndex, int columnIndex) {
-    	return columnIndex == applyColumn;
+    public boolean getApply(int i) {
+        return apply[i];
     }
 
-	@Override
+    public int getRowCount() {
+        return corrections.size();
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex) {
+        if (columnIndex == applyColumn)
+            return Boolean.class;
+        return String.class;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex) {
+        if (columnIndex == applyColumn)
+            return tr("Apply?");
+
+        return getCorrectionColumnName(columnIndex);
+    }
+
+    @Override
+    public boolean isCellEditable(int rowIndex, int columnIndex) {
+        return columnIndex == applyColumn;
+    }
+
+    @Override
     public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
-    	if (columnIndex == applyColumn && aValue instanceof Boolean)
-    		apply[rowIndex] = (Boolean)aValue;
+        if (columnIndex == applyColumn && aValue instanceof Boolean)
+            apply[rowIndex] = (Boolean)aValue;
     }
 
     public Object getValueAt(int rowIndex, int colIndex) {
-    	if (colIndex == applyColumn)
-    		return apply[rowIndex];
-    	
-    	return getCorrectionValueAt(rowIndex, colIndex);
-	}
+        if (colIndex == applyColumn)
+            return apply[rowIndex];
+
+        return getCorrectionValueAt(rowIndex, colIndex);
+    }
 }
Index: trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java	(revision 1169)
@@ -22,14 +22,14 @@
 public class ReverseWayTagCorrector extends TagCorrector<Way> {
 
-	private static class PrefixSuffixSwitcher {
+    private static class PrefixSuffixSwitcher {
 
-		private final String a;
-		private final String b;
-		private final Pattern startPattern;
-		private final Pattern endPattern;
+        private final String a;
+        private final String b;
+        private final Pattern startPattern;
+        private final Pattern endPattern;
 
-		private final String SEPARATOR = "[:_]?";
-		
-		public PrefixSuffixSwitcher(String a, String b) {
+        private final String SEPARATOR = "[:_]?";
+
+        public PrefixSuffixSwitcher(String a, String b) {
             this.a = a;
             this.b = b;
@@ -40,101 +40,101 @@
                     SEPARATOR + "(" + a + "|" + b + ")$",
                     Pattern.CASE_INSENSITIVE);
-		}
+        }
 
-		public String apply(String text) {
-			Matcher m = startPattern.matcher(text);
-			if (!m.lookingAt())
-				m = endPattern.matcher(text);
+        public String apply(String text) {
+            Matcher m = startPattern.matcher(text);
+            if (!m.lookingAt())
+                m = endPattern.matcher(text);
 
-			if (m.lookingAt()) {
-				String leftRight = m.group(1).toLowerCase();
+            if (m.lookingAt()) {
+                String leftRight = m.group(1).toLowerCase();
 
-				StringBuilder result = new StringBuilder();
-				result.append(text.substring(0, m.start(1)));
-				result.append(leftRight.equals(a) ? b : a);
-				result.append(text.substring(m.end(1)));
-				
-				return result.toString();
-			}
-			return text;
-		}
-	}
+                StringBuilder result = new StringBuilder();
+                result.append(text.substring(0, m.start(1)));
+                result.append(leftRight.equals(a) ? b : a);
+                result.append(text.substring(m.end(1)));
 
-	private static PrefixSuffixSwitcher[] prefixSuffixSwitchers = 
-	        new PrefixSuffixSwitcher[] {
-	            new PrefixSuffixSwitcher("left", "right"),
-	            new PrefixSuffixSwitcher("forward", "backward") 
-	        };
+                return result.toString();
+            }
+            return text;
+        }
+    }
 
-	@Override
-	public Collection<Command> execute(Way way) throws UserCancelException {
-		Map<OsmPrimitive, List<TagCorrection>> tagCorrectionsMap = 
-		        new HashMap<OsmPrimitive, List<TagCorrection>>();
+    private static PrefixSuffixSwitcher[] prefixSuffixSwitchers =
+            new PrefixSuffixSwitcher[] {
+                new PrefixSuffixSwitcher("left", "right"),
+                new PrefixSuffixSwitcher("forward", "backward")
+            };
 
-		ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
-		primitives.add(way);
-		primitives.addAll(way.nodes);
+    @Override
+    public Collection<Command> execute(Way way) throws UserCancelException {
+        Map<OsmPrimitive, List<TagCorrection>> tagCorrectionsMap =
+                new HashMap<OsmPrimitive, List<TagCorrection>>();
 
-		for (OsmPrimitive primitive : primitives) {
-			tagCorrectionsMap.put(primitive, new ArrayList<TagCorrection>());
+        ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
+        primitives.add(way);
+        primitives.addAll(way.nodes);
 
-			for (String key : primitive.keySet()) {
-				String newKey = key;
-				String value = primitive.get(key);
-				String newValue = value;
+        for (OsmPrimitive primitive : primitives) {
+            tagCorrectionsMap.put(primitive, new ArrayList<TagCorrection>());
 
-				if (key.equals("oneway")) {
-					if (value.equals("-1"))
-						newValue = OsmUtils.trueval;
-					else {
-						Boolean boolValue = OsmUtils.getOsmBoolean(value);
-						if (boolValue != null && boolValue.booleanValue()) {
-							newValue = "-1";
-						}
-					}
-				} else {
-					for (PrefixSuffixSwitcher prefixSuffixSwitcher : prefixSuffixSwitchers) {
-						newKey = prefixSuffixSwitcher.apply(key);
-						if (!key.equals(newKey))
-							break;
-					}
-				}
+            for (String key : primitive.keySet()) {
+                String newKey = key;
+                String value = primitive.get(key);
+                String newValue = value;
 
-				if (!key.equals(newKey) || !value.equals(newValue))
-					tagCorrectionsMap.get(primitive).add(
-					        new TagCorrection(key, value, newKey, newValue));
-			}
-		}
+                if (key.equals("oneway")) {
+                    if (value.equals("-1"))
+                        newValue = OsmUtils.trueval;
+                    else {
+                        Boolean boolValue = OsmUtils.getOsmBoolean(value);
+                        if (boolValue != null && boolValue.booleanValue()) {
+                            newValue = "-1";
+                        }
+                    }
+                } else {
+                    for (PrefixSuffixSwitcher prefixSuffixSwitcher : prefixSuffixSwitchers) {
+                        newKey = prefixSuffixSwitcher.apply(key);
+                        if (!key.equals(newKey))
+                            break;
+                    }
+                }
 
-		Map<OsmPrimitive, List<RoleCorrection>> roleCorrectionMap = 
-		        new HashMap<OsmPrimitive, List<RoleCorrection>>();
-		roleCorrectionMap.put(way, new ArrayList<RoleCorrection>());
+                if (!key.equals(newKey) || !value.equals(newValue))
+                    tagCorrectionsMap.get(primitive).add(
+                            new TagCorrection(key, value, newKey, newValue));
+            }
+        }
 
-		for (Relation relation : Main.ds.relations) {
-			for (RelationMember member : relation.members) {
-				if (!member.member.realEqual(way, true)
-				        || member.role.length() == 0)
-					continue;
+        Map<OsmPrimitive, List<RoleCorrection>> roleCorrectionMap =
+                new HashMap<OsmPrimitive, List<RoleCorrection>>();
+        roleCorrectionMap.put(way, new ArrayList<RoleCorrection>());
 
-				boolean found = false;
-				String newRole = null;
-				for (PrefixSuffixSwitcher prefixSuffixSwitcher : prefixSuffixSwitchers) {
-					newRole = prefixSuffixSwitcher.apply(member.role);
-					if (!newRole.equals(member.role)) {
-						found = true;
-						break;
-					}
-				}
+        for (Relation relation : Main.ds.relations) {
+            for (RelationMember member : relation.members) {
+                if (!member.member.realEqual(way, true)
+                        || member.role.length() == 0)
+                    continue;
 
-				if (found)
-					roleCorrectionMap.get(way).add(
-					        new RoleCorrection(relation, member, newRole));
-			}
-		}
+                boolean found = false;
+                String newRole = null;
+                for (PrefixSuffixSwitcher prefixSuffixSwitcher : prefixSuffixSwitchers) {
+                    newRole = prefixSuffixSwitcher.apply(member.role);
+                    if (!newRole.equals(member.role)) {
+                        found = true;
+                        break;
+                    }
+                }
 
-		return applyCorrections(tagCorrectionsMap, roleCorrectionMap,
-		        tr("When reverting this way, following changes to properties "
-		                + "of the way and its nodes are suggested in order "
-		                + "to maintain data consistency."));
-	}
+                if (found)
+                    roleCorrectionMap.get(way).add(
+                            new RoleCorrection(relation, member, newRole));
+            }
+        }
+
+        return applyCorrections(tagCorrectionsMap, roleCorrectionMap,
+                tr("When reverting this way, following changes to properties "
+                        + "of the way and its nodes are suggested in order "
+                        + "to maintain data consistency."));
+    }
 }
Index: trunk/src/org/openstreetmap/josm/corrector/TagCorrection.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/TagCorrection.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/TagCorrection.java	(revision 1169)
@@ -4,23 +4,23 @@
 public class TagCorrection implements Correction {
 
-	public final String oldKey;
-	public final String newKey;
-	public final String oldValue;
-	public final String newValue;
+    public final String oldKey;
+    public final String newKey;
+    public final String oldValue;
+    public final String newValue;
 
-	public TagCorrection(String oldKey, String oldValue, String newKey,
+    public TagCorrection(String oldKey, String oldValue, String newKey,
             String newValue) {
-		this.oldKey = oldKey;
-		this.oldValue = oldValue;
-		this.newKey = newKey;
-		this.newValue = newValue;
-	}
+        this.oldKey = oldKey;
+        this.oldValue = oldValue;
+        this.newKey = newKey;
+        this.newValue = newValue;
+    }
 
-	public boolean isKeyChanged() {
-		return !newKey.equals(oldKey);
-	}
+    public boolean isKeyChanged() {
+        return !newKey.equals(oldKey);
+    }
 
-	public boolean isValueChanged() {
-		return !newValue.equals(oldValue);
-	}
+    public boolean isValueChanged() {
+        return !newValue.equals(oldValue);
+    }
 }
Index: trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTable.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTable.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTable.java	(revision 1169)
@@ -7,7 +7,7 @@
         CorrectionTable<TagCorrectionTableModel> {
 
-	public TagCorrectionTable(List<TagCorrection> tagCorrections) {
-		super(new TagCorrectionTableModel(tagCorrections));
-	}
+    public TagCorrectionTable(List<TagCorrection> tagCorrections) {
+        super(new TagCorrectionTableModel(tagCorrections));
+    }
 
 }
Index: trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTableModel.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTableModel.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/TagCorrectionTableModel.java	(revision 1169)
@@ -8,49 +8,49 @@
 public class TagCorrectionTableModel extends CorrectionTableModel<TagCorrection> {
 
-	public TagCorrectionTableModel(List<TagCorrection> tagCorrections) {
-		super(tagCorrections);
-	}
+    public TagCorrectionTableModel(List<TagCorrection> tagCorrections) {
+        super(tagCorrections);
+    }
 
-	@Override
-	public int getColumnCount() {
-		return 5;
-	}
+    @Override
+    public int getColumnCount() {
+        return 5;
+    }
 
-	@Override
-	public String getCorrectionColumnName(int colIndex) {
-		switch (colIndex) {
-		case 0:
-			return tr("Old key");
-		case 1:
-			return tr("Old value");
-		case 2:
-			return tr("New key");
-		case 3:
-			return tr("New value");
-		}
-		return null;
-	}
+    @Override
+    public String getCorrectionColumnName(int colIndex) {
+        switch (colIndex) {
+        case 0:
+            return tr("Old key");
+        case 1:
+            return tr("Old value");
+        case 2:
+            return tr("New key");
+        case 3:
+            return tr("New value");
+        }
+        return null;
+    }
 
     public Object getCorrectionValueAt(int rowIndex, int colIndex) {
-		TagCorrection tagCorrection = getCorrections().get(rowIndex);
+        TagCorrection tagCorrection = getCorrections().get(rowIndex);
 
-		switch (colIndex) {
-		case 0:
-			return tagCorrection.oldKey;
-		case 1:
-			return tagCorrection.oldValue;
-		case 2:
-			return tagCorrection.newKey;
-		case 3:
-			return tagCorrection.newValue;
-		}
-		return null;
-	}
+        switch (colIndex) {
+        case 0:
+            return tagCorrection.oldKey;
+        case 1:
+            return tagCorrection.oldValue;
+        case 2:
+            return tagCorrection.newKey;
+        case 3:
+            return tagCorrection.newValue;
+        }
+        return null;
+    }
 
-	protected boolean isBoldCell(int row, int column) {
-		TagCorrection tagCorrection = getCorrections().get(row);
-		return (column == 2 && tagCorrection.isKeyChanged())
-		        || (column == 3 && tagCorrection.isValueChanged());
-	}
+    protected boolean isBoldCell(int row, int column) {
+        TagCorrection tagCorrection = getCorrections().get(row);
+        return (column == 2 && tagCorrection.isKeyChanged())
+                || (column == 3 && tagCorrection.isValueChanged());
+    }
 
 }
Index: trunk/src/org/openstreetmap/josm/corrector/TagCorrector.java
===================================================================
--- trunk/src/org/openstreetmap/josm/corrector/TagCorrector.java	(revision 1107)
+++ trunk/src/org/openstreetmap/josm/corrector/TagCorrector.java	(revision 1169)
@@ -33,113 +33,113 @@
 public abstract class TagCorrector<P extends OsmPrimitive> {
 
-	public abstract Collection<Command> execute(P primitive) 
-	    throws UserCancelException;
+    public abstract Collection<Command> execute(P primitive)
+        throws UserCancelException;
 
-    private String[] applicationOptions = new String[] { 
-        tr("Apply selected changes"), 
-        tr("Don't apply changes"), 
-        tr("Cancel") 
+    private String[] applicationOptions = new String[] {
+        tr("Apply selected changes"),
+        tr("Don't apply changes"),
+        tr("Cancel")
     };
-    
-	protected Collection<Command> applyCorrections(
-	        Map<OsmPrimitive, List<TagCorrection>> tagCorrectionsMap,
-	        Map<OsmPrimitive, List<RoleCorrection>> roleCorrectionMap,
-	        String description) throws UserCancelException {
 
-		boolean hasCorrections = false;
-		for (List<TagCorrection> tagCorrectionList : tagCorrectionsMap.values()) {
-			if (!tagCorrectionList.isEmpty()) {
-				hasCorrections = true;
-				break;
-			}
-		}
+    protected Collection<Command> applyCorrections(
+            Map<OsmPrimitive, List<TagCorrection>> tagCorrectionsMap,
+            Map<OsmPrimitive, List<RoleCorrection>> roleCorrectionMap,
+            String description) throws UserCancelException {
 
-		if (!hasCorrections)
-			for (List<RoleCorrection> roleCorrectionList : roleCorrectionMap
-			        .values()) {
-				if (!roleCorrectionList.isEmpty()) {
-					hasCorrections = true;
-					break;
-				}
-			}
+        boolean hasCorrections = false;
+        for (List<TagCorrection> tagCorrectionList : tagCorrectionsMap.values()) {
+            if (!tagCorrectionList.isEmpty()) {
+                hasCorrections = true;
+                break;
+            }
+        }
 
-		if (hasCorrections) {
-			Collection<Command> commands = new ArrayList<Command>();
-			Map<OsmPrimitive, TagCorrectionTable> tagTableMap = 
-			    new HashMap<OsmPrimitive, TagCorrectionTable>();
-			Map<OsmPrimitive, RoleCorrectionTable> roleTableMap = 
-			    new HashMap<OsmPrimitive, RoleCorrectionTable>();
+        if (!hasCorrections)
+            for (List<RoleCorrection> roleCorrectionList : roleCorrectionMap
+                    .values()) {
+                if (!roleCorrectionList.isEmpty()) {
+                    hasCorrections = true;
+                    break;
+                }
+            }
 
-			NameVisitor nameVisitor = new NameVisitor();
+        if (hasCorrections) {
+            Collection<Command> commands = new ArrayList<Command>();
+            Map<OsmPrimitive, TagCorrectionTable> tagTableMap =
+                new HashMap<OsmPrimitive, TagCorrectionTable>();
+            Map<OsmPrimitive, RoleCorrectionTable> roleTableMap =
+                new HashMap<OsmPrimitive, RoleCorrectionTable>();
 
-			final JPanel p = new JPanel(new GridBagLayout());
+            NameVisitor nameVisitor = new NameVisitor();
 
-			final JMultilineLabel label1 = new JMultilineLabel(description);
-			label1.setMaxWidth(400);
-			p.add(label1, GBC.eop());
+            final JPanel p = new JPanel(new GridBagLayout());
 
-			final JMultilineLabel label2 = new JMultilineLabel(
-			        tr("Please select which property changes you want to apply."));
-			label2.setMaxWidth(400);
-			p.add(label2, GBC.eop());
+            final JMultilineLabel label1 = new JMultilineLabel(description);
+            label1.setMaxWidth(400);
+            p.add(label1, GBC.eop());
 
-			for (OsmPrimitive primitive : tagCorrectionsMap.keySet()) {
-				final List<TagCorrection> tagCorrections = tagCorrectionsMap
-				        .get(primitive);
+            final JMultilineLabel label2 = new JMultilineLabel(
+                    tr("Please select which property changes you want to apply."));
+            label2.setMaxWidth(400);
+            p.add(label2, GBC.eop());
 
-				if (tagCorrections.isEmpty())
-					continue;
+            for (OsmPrimitive primitive : tagCorrectionsMap.keySet()) {
+                final List<TagCorrection> tagCorrections = tagCorrectionsMap
+                        .get(primitive);
 
-				primitive.visit(nameVisitor);
+                if (tagCorrections.isEmpty())
+                    continue;
 
-				final JLabel propertiesLabel = new JLabel(tr("Properties of "));
-				p.add(propertiesLabel, GBC.std());
+                primitive.visit(nameVisitor);
 
-				final JLabel primitiveLabel = new JLabel(
-				        nameVisitor.name + ":", nameVisitor.icon, JLabel.LEFT);
-				p.add(primitiveLabel, GBC.eol());
+                final JLabel propertiesLabel = new JLabel(tr("Properties of "));
+                p.add(propertiesLabel, GBC.std());
 
-				final TagCorrectionTable table = new TagCorrectionTable(
-				        tagCorrections);
-				final JScrollPane scrollPane = new JScrollPane(table);
-				p.add(scrollPane, GBC.eop());
+                final JLabel primitiveLabel = new JLabel(
+                        nameVisitor.name + ":", nameVisitor.icon, JLabel.LEFT);
+                p.add(primitiveLabel, GBC.eol());
 
-				tagTableMap.put(primitive, table);
-			}
+                final TagCorrectionTable table = new TagCorrectionTable(
+                        tagCorrections);
+                final JScrollPane scrollPane = new JScrollPane(table);
+                p.add(scrollPane, GBC.eop());
 
-			for (OsmPrimitive primitive : roleCorrectionMap.keySet()) {
-				final List<RoleCorrection> roleCorrections = roleCorrectionMap
-				        .get(primitive);
-				if (roleCorrections.isEmpty())
-					continue;
+                tagTableMap.put(primitive, table);
+            }
 
-				primitive.visit(nameVisitor);
+            for (OsmPrimitive primitive : roleCorrectionMap.keySet()) {
+                final List<RoleCorrection> roleCorrections = roleCorrectionMap
+                        .get(primitive);
+                if (roleCorrections.isEmpty())
+                    continue;
 
-				final JLabel rolesLabel = new JLabel(
-				        tr("Roles in relations referring to"));
-				p.add(rolesLabel, GBC.std());
+                primitive.visit(nameVisitor);
 
-				final JLabel primitiveLabel = new JLabel(
-				        nameVisitor.name + ":", nameVisitor.icon, JLabel.LEFT);
-				p.add(primitiveLabel, GBC.eol());
+                final JLabel rolesLabel = new JLabel(
+                        tr("Roles in relations referring to"));
+                p.add(rolesLabel, GBC.std());
 
-				final RoleCorrectionTable table = new RoleCorrectionTable(
-				        roleCorrections);
-				final JScrollPane scrollPane = new JScrollPane(table);
-				p.add(scrollPane, GBC.eop());
+                final JLabel primitiveLabel = new JLabel(
+                        nameVisitor.name + ":", nameVisitor.icon, JLabel.LEFT);
+                p.add(primitiveLabel, GBC.eol());
 
-				roleTableMap.put(primitive, table);
-			}
+                final RoleCorrectionTable table = new RoleCorrectionTable(
+                        roleCorrections);
+                final JScrollPane scrollPane = new JScrollPane(table);
+                p.add(scrollPane, GBC.eop());
 
-			int answer = JOptionPane.showOptionDialog(Main.parent, p,
+                roleTableMap.put(primitive, table);
+            }
+
+            int answer = JOptionPane.showOptionDialog(Main.parent, p,
                     tr("Automatic tag correction"), JOptionPane.YES_NO_CANCEL_OPTION,
-                    JOptionPane.PLAIN_MESSAGE, null, 
+                    JOptionPane.PLAIN_MESSAGE, null,
                     applicationOptions, applicationOptions[0]);
 
-			if (answer == JOptionPane.YES_OPTION) {
-				for (OsmPrimitive primitive : tagCorrectionsMap.keySet()) {
-					List<TagCorrection> tagCorrections = 
+            if (answer == JOptionPane.YES_OPTION) {
+                for (OsmPrimitive primitive : tagCorrectionsMap.keySet()) {
+                    List<TagCorrection> tagCorrections =
                         tagCorrectionsMap.get(primitive);
-                    
+
                     // create the clone
                     OsmPrimitive clone = null;
@@ -147,47 +147,47 @@
                     else if (primitive instanceof Node) clone = new Node((Node)primitive);
                     else if (primitive instanceof Relation) clone = new Relation((Relation)primitive);
-                    
+
                     // use this structure to remember keys that have been set already so that
                     // they're not dropped by a later step
                     Set<String> keysChanged = new HashSet<String>();
-                    
+
                     // apply all changes to this clone
-					for (int i = 0; i < tagCorrections.size(); i++) {
-						if (tagTableMap.get(primitive).getCorrectionTableModel().getApply(i)) {
-							TagCorrection tagCorrection = tagCorrections.get(i);
-							if (tagCorrection.isKeyChanged() && !keysChanged.contains(tagCorrection.oldKey)) clone.remove(tagCorrection.oldKey);
-							clone.put(tagCorrection.newKey, tagCorrection.newValue);
-							keysChanged.add(tagCorrection.newKey);
-						}
-					}
-                    
+                    for (int i = 0; i < tagCorrections.size(); i++) {
+                        if (tagTableMap.get(primitive).getCorrectionTableModel().getApply(i)) {
+                            TagCorrection tagCorrection = tagCorrections.get(i);
+                            if (tagCorrection.isKeyChanged() && !keysChanged.contains(tagCorrection.oldKey)) clone.remove(tagCorrection.oldKey);
+                            clone.put(tagCorrection.newKey, tagCorrection.newValue);
+                            keysChanged.add(tagCorrection.newKey);
+                        }
+                    }
+
                     // save the clone
                     if (!keysChanged.isEmpty()) commands.add(new ChangeCommand(primitive, clone));
-				}
-				for (OsmPrimitive primitive : roleCorrectionMap.keySet()) {
-					List<RoleCorrection> roleCorrections = roleCorrectionMap
-					        .get(primitive);
-					for (int i = 0; i < roleCorrections.size(); i++) {
-						if (roleTableMap.get(primitive)
-						        .getCorrectionTableModel().getApply(i)) {
-							RoleCorrection roleCorrection = roleCorrections
-							        .get(i);
-							Relation newRelation = new Relation(
-							        roleCorrection.relation);
-							for (RelationMember member : newRelation.members)
-								if (member.equals(roleCorrection.member))
-									member.role = roleCorrection.newRole;
-							commands.add(new ChangeCommand(
-							        roleCorrection.relation, newRelation));
-						}
-					}
-				}
-			} else if (answer != JOptionPane.NO_OPTION) {
-			    throw new UserCancelException();
-			}
-			return commands;
-		}
+                }
+                for (OsmPrimitive primitive : roleCorrectionMap.keySet()) {
+                    List<RoleCorrection> roleCorrections = roleCorrectionMap
+                            .get(primitive);
+                    for (int i = 0; i < roleCorrections.size(); i++) {
+                        if (roleTableMap.get(primitive)
+                                .getCorrectionTableModel().getApply(i)) {
+                            RoleCorrection roleCorrection = roleCorrections
+                                    .get(i);
+                            Relation newRelation = new Relation(
+                                    roleCorrection.relation);
+                            for (RelationMember member : newRelation.members)
+                                if (member.equals(roleCorrection.member))
+                                    member.role = roleCorrection.newRole;
+                            commands.add(new ChangeCommand(
+                                    roleCorrection.relation, newRelation));
+                        }
+                    }
+                }
+            } else if (answer != JOptionPane.NO_OPTION) {
+                throw new UserCancelException();
+            }
+            return commands;
+        }
 
-		return Collections.emptyList();
-	}
+        return Collections.emptyList();
+    }
 }
