Ticket #17268: clear_ignored_errors_v22.patch

File clear_ignored_errors_v22.patch, 25.9 KB (added by GerdP, 5 years ago)

  • src/org/openstreetmap/josm/data/preferences/sources/ValidatorPrefHelper.java

     
    4444    /** The preferences for ignored severity other */
    4545    public static final BooleanProperty PREF_OTHER = new BooleanProperty(PREFIX + ".other", false);
    4646
     47    /** The preferences key for the ignorelist */
     48    public static final String PREF_IGNORELIST = PREFIX + ".ignorelist";
     49
     50    /** The preferences key for the ignorelist backup */
     51    public static final String PREF_IGNORELIST_BACKUP = PREFIX + ".ignorelist.bak";
     52
     53    /** The preferences key for whether or not the ignorelist backup should be cleared on start */
     54    public static final BooleanProperty PREF_IGNORELIST_KEEP_BACKUP = new BooleanProperty(PREFIX + ".ignorelist.bak.keep", false);
     55
    4756    /**
    4857     * The preferences key for enabling the permanent filtering
    4958     * of the displayed errors in the tree regarding the current selection

  • src/org/openstreetmap/josm/data/validation/OsmValidator.java

     
    77import java.io.File;
    88import java.io.FileNotFoundException;
    99import java.io.IOException;
    10 import java.io.PrintWriter;
    1110import java.nio.charset.StandardCharsets;
    1211import java.nio.file.Files;
    1312import java.nio.file.Path;
    … …  
    1817import java.util.Collections;
    1918import java.util.EnumMap;
    2019import java.util.HashMap;
     20import java.util.Iterator;
    2121import java.util.List;
    2222import java.util.Map;
     23import java.util.Map.Entry;
    2324import java.util.SortedMap;
    2425import java.util.TreeMap;
    2526import java.util.TreeSet;
    … …  
    8889    /** Grid detail, multiplier of east,north values for valuable cell sizing */
    8990    private static double griddetail;
    9091
    91     private static final Collection<String> ignoredErrors = new TreeSet<>();
    92 
     92    private static final SortedMap<String, String> ignoredErrors = new TreeMap<>();
    9393    /**
    9494     * All registered tests
    9595     */
    … …  
    169169    public static void initialize() {
    170170        checkValidatorDir();
    171171        initializeGridDetail();
    172         loadIgnoredErrors(); //FIXME: load only when needed
     172        loadIgnoredErrors();
    173173    }
    174174
    175175    /**
    … …  
    204204    private static void loadIgnoredErrors() {
    205205        ignoredErrors.clear();
    206206        if (ValidatorPrefHelper.PREF_USE_IGNORE.get()) {
     207            Config.getPref().getListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST).forEach(ignoredErrors::putAll);
    207208            Path path = Paths.get(getValidatorDir()).resolve("ignorederrors");
    208209            try {
    209210                if (path.toFile().exists()) {
    210211                    try {
    211                         ignoredErrors.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
     212                        TreeSet<String> treeSet = new TreeSet<>();
     213                        treeSet.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
     214                        treeSet.forEach(ignore -> ignoredErrors.putIfAbsent(ignore, ""));
     215
     216                        saveIgnoredErrors();
     217                        Files.deleteIfExists(path);
    212218                    } catch (FileNotFoundException e) {
    213219                        Logging.debug(Logging.getErrorMessage(e));
    214220                    } catch (IOException e) {
    … …  
    219225                Logging.log(Logging.LEVEL_ERROR, "Unable to load ignored errors", e);
    220226            }
    221227        }
     228        cleanupIgnoredErrors();
    222229    }
    223230
    224231    /**
    … …  
    228235     * @see TestError#getIgnoreSubGroup()
    229236     */
    230237    public static void addIgnoredError(String s) {
    231         ignoredErrors.add(s);
     238        addIgnoredError(s, "");
    232239    }
    233240
    234241    /**
     242     * Adds an ignored error
     243     * @param s The ignore group / sub group name
     244     * @param description What the error actually is
     245     * @see TestError#getIgnoreGroup()
     246     * @see TestError#getIgnoreSubGroup()
     247     */
     248    public static void addIgnoredError(String s, String description) {
     249        if (description == null) description = "";
     250
     251        ignoredErrors.put(s, description);
     252    }
     253
     254    /**
     255     *  make sure that we don't keep single entries for a "group ignore"
     256     */
     257    private static void cleanupIgnoredErrors() {
     258        if (ignoredErrors.size() > 1) {
     259            List<String> toRemove = new ArrayList<>();
     260
     261            Iterator<Entry<String, String>> iter = ignoredErrors.entrySet().iterator();
     262            Entry<String, String> last = iter.next();
     263            while (iter.hasNext()) {
     264                Entry<String, String> entry = iter.next();
     265                if (entry.getKey().startsWith(last.getKey())) {
     266                    toRemove.add(entry.getKey());
     267                } else {
     268                    last = entry;
     269                }
     270            }
     271            toRemove.forEach(ignoredErrors::remove);
     272        }
     273    }
     274
     275    /**
    235276     * Check if a error should be ignored
    236277     * @param s The ignore group / sub group name
    237278     * @return <code>true</code> to ignore that error
    238279     */
    239280    public static boolean hasIgnoredError(String s) {
    240         return ignoredErrors.contains(s);
     281        return ignoredErrors.containsKey(s);
    241282    }
    242283
    243284    /**
    244      * Saves the names of the ignored errors to a file
     285     * Get the list of all ignored errors
     286     * @return The <code>Collection&ltString&gt</code> of errors that are ignored
    245287     */
     288    public static SortedMap<String, String> getIgnoredErrors() {
     289        return ignoredErrors;
     290    }
     291
     292    /**
     293     * Reset the error list by deleting {@code validator.ignorelist}
     294     */
     295    public static void resetErrorList() {
     296        saveIgnoredErrors();
     297        backupErrorList();
     298        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, null);
     299        OsmValidator.initialize();
     300    }
     301
     302    /**
     303     * Restore the error list by copying {@code validator.ignorelist.bak} to
     304     * {@code validator.ignorelist}
     305     */
     306    public static void restoreErrorList() {
     307        saveIgnoredErrors();
     308        List<Map<String, String>> tlist = Config.getPref().getListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST_BACKUP);
     309        backupErrorList();
     310        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, tlist);
     311        OsmValidator.initialize();
     312    }
     313
     314    private static void backupErrorList() {
     315        List<Map<String, String>> tlist = Config.getPref().getListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, null);
     316        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST_BACKUP, tlist);
     317    }
     318
     319    /**
     320     * Saves the names of the ignored errors to a preference
     321     */
    246322    public static void saveIgnoredErrors() {
    247         try (PrintWriter out = new PrintWriter(new File(getValidatorDir(), "ignorederrors"), StandardCharsets.UTF_8.name())) {
    248             for (String e : ignoredErrors) {
    249                 out.println(e);
     323        cleanupIgnoredErrors();
     324        List<Map<String, String>> list = new ArrayList<>();
     325        list.add(ignoredErrors);
     326        int i = 0;
     327        while (i < list.size()) {
     328            if (list.get(i) == null || list.get(i).isEmpty()) {
     329                list.remove(i);
     330                continue;
    250331            }
    251         } catch (IOException e) {
    252             Logging.error(e);
     332            i++;
    253333        }
     334        if (list.isEmpty()) list = null;
     335        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, list);
    254336    }
    255337
    256338    /**

  • src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

     
    6363import org.openstreetmap.josm.tools.ImageProvider;
    6464import org.openstreetmap.josm.tools.InputMapUtils;
    6565import org.openstreetmap.josm.tools.JosmRuntimeException;
     66import org.openstreetmap.josm.tools.Pair;
    6667import org.openstreetmap.josm.tools.Shortcut;
    6768import org.xml.sax.SAXException;
    6869
    … …  
    8586    private final SideButton fixButton;
    8687    /** The ignore button */
    8788    private final SideButton ignoreButton;
     89    /** The reset ignorelist button */
     90    private final SideButton ignorelistManagement;
    8891    /** The select button */
    8992    private final SideButton selectButton;
    9093    /** The lookup button */
    … …  
    174177            });
    175178            ignoreButton.setEnabled(false);
    176179            buttons.add(ignoreButton);
     180
     181            if (!ValidatorPrefHelper.PREF_IGNORELIST_KEEP_BACKUP.get()) {
     182                // Clear the backup ignore list
     183                Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST_BACKUP, null);
     184            }
     185            ignorelistManagement = new SideButton(new AbstractAction() {
     186                {
     187                    putValue(NAME, tr("Manage Ignore"));
     188                    putValue(SHORT_DESCRIPTION, tr("Manage the ignore list"));
     189                    new ImageProvider("dialogs", "fix").getResource().attachImageIcon(this, true);
     190                }
     191
     192                @Override
     193                public void actionPerformed(ActionEvent e) {
     194                    ValidatorListManagementDialog dialog = new ValidatorListManagementDialog("Ignore");
     195                    if (dialog.getValue() == 1) {
     196                        // TODO save
     197                    }
     198                }
     199            });
     200            buttons.add(ignorelistManagement);
    177201        } else {
    178202            ignoreButton = null;
     203            ignorelistManagement = null;
    179204        }
     205
    180206        createLayout(tree, true, buttons);
    181207    }
    182208
    … …  
    245271
    246272            Object mainNodeInfo = node.getUserObject();
    247273            if (!(mainNodeInfo instanceof TestError)) {
    248                 Set<String> state = new HashSet<>();
     274                Set<Pair<String, String>> state = new HashSet<>();
    249275                // ask if the whole set should be ignored
    250276                if (asked == JOptionPane.DEFAULT_OPTION) {
    251277                    String[] a = new String[] {tr("Whole group"), tr("Single elements"), tr("Nothing")};
    … …  
    257283                    ValidatorTreePanel.visitTestErrors(node, err -> {
    258284                        err.setIgnored(true);
    259285                        changed.set(true);
    260                         state.add(node.getDepth() == 1 ? err.getIgnoreSubGroup() : err.getIgnoreGroup());
     286                        state.add(new Pair<>(node.getDepth() == 1 ? err.getIgnoreSubGroup() : err.getIgnoreGroup(), err.getMessage()));
    261287                    }, processedNodes);
    262                     for (String s : state) {
    263                         OsmValidator.addIgnoredError(s);
     288                    for (Pair<String, String> s : state) {
     289                        OsmValidator.addIgnoredError(s.a, s.b);
    264290                    }
    265291                    continue;
    266292                } else if (asked == JOptionPane.CANCEL_OPTION || asked == JOptionPane.CLOSED_OPTION) {
    … …  
    271297            ValidatorTreePanel.visitTestErrors(node, error -> {
    272298                String state = error.getIgnoreState();
    273299                if (state != null) {
    274                     OsmValidator.addIgnoredError(state);
     300                    OsmValidator.addIgnoredError(state, error.getMessage());
    275301                }
    276302                changed.set(true);
    277303                error.setIgnored(true);
    … …  
    287313    /**
    288314     * Sets the selection of the map to the current selected items.
    289315     */
    290     @SuppressWarnings("unchecked")
    291316    private void setSelectedItems() {
    292317        DataSet ds = MainApplication.getLayerManager().getActiveDataSet();
    293318        if (tree == null || ds == null)

  • src/org/openstreetmap/josm/gui/dialogs/ValidatorListManagementDialog.java

     
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.gui.dialogs;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
     5
     6import java.awt.GridBagLayout;
     7import java.awt.Rectangle;
     8import java.awt.event.ActionEvent;
     9import java.awt.event.MouseAdapter;
     10import java.awt.event.MouseEvent;
     11import java.util.Enumeration;
     12import java.util.HashMap;
     13import java.util.List;
     14import java.util.Locale;
     15import java.util.Map;
     16import java.util.Map.Entry;
     17import java.util.TreeMap;
     18
     19import javax.swing.AbstractAction;
     20import javax.swing.ImageIcon;
     21import javax.swing.JMenuItem;
     22import javax.swing.JOptionPane;
     23import javax.swing.JPanel;
     24import javax.swing.JPopupMenu;
     25import javax.swing.JScrollPane;
     26import javax.swing.JTree;
     27import javax.swing.tree.DefaultMutableTreeNode;
     28import javax.swing.tree.TreeModel;
     29import javax.swing.tree.TreeNode;
     30import javax.swing.tree.TreePath;
     31
     32import org.openstreetmap.josm.actions.ValidateAction;
     33import org.openstreetmap.josm.data.validation.OsmValidator;
     34import org.openstreetmap.josm.data.validation.TestError;
     35import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
     36import org.openstreetmap.josm.gui.ExtendedDialog;
     37import org.openstreetmap.josm.gui.MainApplication;
     38import org.openstreetmap.josm.gui.MapFrame;
     39import org.openstreetmap.josm.gui.util.GuiHelper;
     40import org.openstreetmap.josm.tools.GBC;
     41import org.openstreetmap.josm.tools.ImageProvider;
     42import org.openstreetmap.josm.tools.Logging;
     43
     44
     45/**
     46 * A management window for the validator's ignorelist
     47 * @author Taylor Smock
     48 * @since xxx
     49 */
     50public class ValidatorListManagementDialog extends ExtendedDialog {
     51    enum BUTTONS {
     52        OK(0, tr("OK"), new ImageProvider("ok")),
     53        CLEAR(1, tr("Clear All"), new ImageProvider("dialogs", "fix")),
     54        RESTORE(2, tr("Restore"), new ImageProvider("copy")),
     55        CANCEL(3, tr("Cancel"), new ImageProvider("cancel"));
     56
     57        private int index;
     58        private String name;
     59        private ImageIcon icon;
     60
     61        BUTTONS(int index, String name, ImageProvider image) {
     62            this.index = index;
     63            this.name = name;
     64            this.icon = image.getResource().getImageIcon();
     65        }
     66
     67        public ImageIcon getImageIcon() {
     68            return icon;
     69        }
     70
     71        public int getIndex() {
     72            return index;
     73        }
     74
     75        public String getName() {
     76            return name;
     77        }
     78    }
     79
     80    private static final String[] BUTTON_TEXTS = {BUTTONS.OK.getName(), BUTTONS.CLEAR.getName(),
     81            BUTTONS.RESTORE.getName(), BUTTONS.CANCEL.getName()
     82    };
     83
     84    private static final ImageIcon[] BUTTON_IMAGES = {BUTTONS.OK.getImageIcon(), BUTTONS.CLEAR.getImageIcon(),
     85            BUTTONS.RESTORE.getImageIcon(), BUTTONS.CANCEL.getImageIcon()
     86    };
     87
     88    private final JPanel panel = new JPanel(new GridBagLayout());
     89
     90    private final JTree ignoreErrors;
     91
     92    private final String type;
     93
     94    /**
     95     * Create a new {@link ValidatorListManagementDialog}
     96     * @param type The type of list to create (first letter may or may not be
     97     * capitalized, it is put into all lowercase after building the title)
     98     */
     99    public ValidatorListManagementDialog(String type) {
     100        super(MainApplication.getMainFrame(), tr("Validator {0} List Management", type), BUTTON_TEXTS, false);
     101        this.type = type.toLowerCase(Locale.ENGLISH);
     102        setButtonIcons(BUTTON_IMAGES);
     103
     104        ignoreErrors = buildList();
     105        JScrollPane scroll = GuiHelper.embedInVerticalScrollPane(ignoreErrors);
     106
     107        panel.add(scroll, GBC.eol().fill(GBC.BOTH).anchor(GBC.CENTER));
     108        setContent(panel);
     109        setDefaultButton(1);
     110        setupDialog();
     111        showDialog();
     112    }
     113
     114    @Override
     115    public void buttonAction(int buttonIndex, ActionEvent evt) {
     116        // Currently OK/Cancel buttons do nothing
     117        final int answer;
     118        if (buttonIndex == BUTTONS.RESTORE.getIndex()) {
     119            dispose();
     120            answer = rerunValidatorPrompt();
     121            if (answer == JOptionPane.YES_OPTION || answer == JOptionPane.NO_OPTION) {
     122                OsmValidator.restoreErrorList();
     123            }
     124        } else if (buttonIndex == BUTTONS.CLEAR.getIndex()) {
     125            dispose();
     126            answer = rerunValidatorPrompt();
     127            if (answer == JOptionPane.YES_OPTION || answer == JOptionPane.NO_OPTION) {
     128                OsmValidator.resetErrorList();
     129            }
     130        } else if (buttonIndex == BUTTONS.OK.getIndex()) {
     131            Map<String, String> errors = OsmValidator.getIgnoredErrors();
     132            Map<String, String> tree = buildIgnore(ignoreErrors);
     133            if (!errors.equals(tree)) {
     134                answer = rerunValidatorPrompt();
     135                if (answer == JOptionPane.YES_OPTION || answer == JOptionPane.NO_OPTION) {
     136                    OsmValidator.resetErrorList();
     137                    Logging.setLogLevel(Logging.LEVEL_DEBUG);
     138                    Logging.debug("Starting to rebuild the error list of size {0}", tree.size());
     139                    tree.forEach((ignore, description) -> {
     140                        Logging.debug("Adding {0} with description {1}", ignore, description);
     141                        OsmValidator.addIgnoredError(ignore, description);
     142                    });
     143                    OsmValidator.saveIgnoredErrors();
     144                    OsmValidator.initialize();
     145                }
     146            }
     147            dispose();
     148        } else {
     149            super.buttonAction(buttonIndex, evt);
     150        }
     151    }
     152
     153    /**
     154     * Build a {@code HashMap} from a tree of ignored errors
     155     * @param tree The JTree of ignored errors
     156     * @return A {@code HashMap} of the ignored errors for comparison
     157     */
     158    public Map<String, String> buildIgnore(JTree tree) {
     159        TreeModel model = tree.getModel();
     160        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
     161        return buildIgnore(model, root);
     162    }
     163
     164    private static Map<String, String> buildIgnore(TreeModel model, DefaultMutableTreeNode node) {
     165        Logging.setLogLevel(Logging.LEVEL_DEBUG);
     166        HashMap<String, String> rHashMap = new HashMap<>();
     167
     168        String osmids = node.getUserObject().toString();
     169        String description = "";
     170
     171        if (!model.getRoot().equals(node)) description = ((DefaultMutableTreeNode) node.getParent()).getUserObject().toString();
     172        if (!osmids.matches("^[0-9]+_.*")) osmids = "";
     173
     174        for (int i = 0; i < model.getChildCount(node); i++) {
     175            DefaultMutableTreeNode child = (DefaultMutableTreeNode) model.getChild(node, i);
     176            if (model.getChildCount(child) == 0) {
     177                String ignoreName = child.getUserObject().toString();
     178                if (ignoreName.matches("^(r|w|n)_.*")) {
     179                    osmids += ":" + child.getUserObject().toString();
     180                } else if (ignoreName.matches("^[0-9]+_.*")) {
     181                    rHashMap.put(ignoreName, description);
     182                }
     183            } else {
     184                rHashMap.putAll(buildIgnore(model, child));
     185            }
     186        }
     187        if (!osmids.isEmpty() && osmids.indexOf(':') != 0) rHashMap.put(osmids, description);
     188        return rHashMap;
     189    }
     190
     191    private static DefaultMutableTreeNode inTree(DefaultMutableTreeNode root, String name) {
     192        @SuppressWarnings("unchecked")
     193        Enumeration<TreeNode> trunks = root.children();
     194        while (trunks.hasMoreElements()) {
     195            TreeNode ttrunk = trunks.nextElement();
     196            if (ttrunk instanceof DefaultMutableTreeNode) {
     197                DefaultMutableTreeNode trunk = (DefaultMutableTreeNode) ttrunk;
     198                if (name.equals(trunk.getUserObject())) {
     199                    return trunk;
     200                }
     201            }
     202        }
     203        return new DefaultMutableTreeNode(name);
     204    }
     205
     206    /**
     207     * Build a JTree with a list
     208     * @return &lttype&gtlist as a {@code JTree}
     209     */
     210    public JTree buildList() {
     211        TreeMap<String, String> map = new TreeMap<>();
     212        if ("ignore".equals(type)) {
     213            Map<String, String> tmap;
     214            tmap = OsmValidator.getIgnoredErrors();
     215            if (tmap.isEmpty()) {
     216                OsmValidator.initialize();
     217                tmap = OsmValidator.getIgnoredErrors();
     218            }
     219            map.putAll(tmap);
     220        } else {
     221            Logging.error(tr("Cannot understand the following type: {0}", type));
     222            return null;
     223        }
     224        DefaultMutableTreeNode root = new DefaultMutableTreeNode(tr("{0} list", type));
     225
     226        for (Entry<String, String> e: map.entrySet()) {
     227            String key = e.getKey();
     228            String value = e.getValue();
     229            String[] osmobjects = key.split(":(r|w|n)_");
     230            DefaultMutableTreeNode trunk;
     231            DefaultMutableTreeNode branch;
     232
     233            if (value != null && !value.isEmpty()) {
     234                trunk = inTree(root, value);
     235                branch = inTree(trunk, osmobjects[0]);
     236                trunk.add(branch);
     237            } else {
     238                trunk = inTree(root, osmobjects[0]);
     239                branch = trunk;
     240            }
     241            for (int i = 1; i < osmobjects.length; i++) {
     242                String osmid = osmobjects[i];
     243                int index = key.indexOf(osmid);
     244                char type = key.charAt(index - 2);
     245                DefaultMutableTreeNode leaf = new DefaultMutableTreeNode(type + "_" + osmid);
     246                branch.add(leaf);
     247            }
     248            root.add(trunk);
     249        }
     250        JTree tree = new JTree(root);
     251        tree.setRootVisible(false);
     252        tree.setShowsRootHandles(true);
     253        tree.addMouseListener(new MouseAdapter() {
     254            @Override
     255            public void mouseClicked(MouseEvent e) {
     256                if (e.isPopupTrigger()) {
     257                    TreePath[] paths = tree.getSelectionPaths();
     258                    if (paths == null) return;
     259                    Rectangle bounds = tree.getUI().getPathBounds(tree, paths[0]);
     260                    if (bounds != null && bounds.contains(e.getX(), e.getY())) {
     261                        JPopupMenu menu = new JPopupMenu();
     262                        JMenuItem delete = new JMenuItem(new AbstractAction(tr("Delete")) {
     263                            @Override
     264                            public void actionPerformed(ActionEvent e1) {
     265                                for (TreePath path : paths) {
     266                                    tree.clearSelection();
     267                                    tree.addSelectionPath(path);
     268                                    DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
     269                                    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
     270                                    node.removeAllChildren();
     271                                    while (node.getChildCount() == 0) {
     272                                        node.removeFromParent();
     273                                        node = parent;
     274                                        if (parent.isRoot()) break;
     275                                        parent = (DefaultMutableTreeNode) node.getParent();
     276                                    }
     277                                }
     278                                tree.updateUI();
     279                            }
     280                        });
     281                        menu.add(delete);
     282                        menu.show(e.getComponent(), e.getX(), e.getY());
     283                    }
     284                }
     285            }
     286        });
     287        return tree;
     288    }
     289
     290    /**
     291     * Prompt to rerun the validator when the ignore list changes
     292     * @return {@code JOptionPane.YES_OPTION}, {@code JOptionPane.NO_OPTION},
     293     *  or {@code JOptionPane.CANCEL_OPTION}
     294     */
     295    public int rerunValidatorPrompt() {
     296        MapFrame map = MainApplication.getMap();
     297        List<TestError> errors = map.validatorDialog.tree.getErrors();
     298        ValidateAction validateAction = ValidatorDialog.validateAction;
     299        if (!validateAction.isEnabled() || errors == null || errors.isEmpty()) return JOptionPane.NO_OPTION;
     300        final int answer = ConditionalOptionPaneUtil.showOptionDialog(
     301                "rerun_validation_when_ignorelist_changed",
     302                MainApplication.getMainFrame(),
     303                tr("{0}Should the validation be rerun?{1}", "<hmtl><h3>", "</h3></html>"),
     304                tr("Ignored error filter changed"),
     305                JOptionPane.YES_NO_CANCEL_OPTION,
     306                JOptionPane.QUESTION_MESSAGE,
     307                null,
     308                null);
     309        if (answer == JOptionPane.YES_OPTION) {
     310            validateAction.doValidate(true);
     311        }
     312        return answer;
     313    }
     314}

  • src/org/openstreetmap/josm/spi/preferences/MapListSetting.java

     
    66import java.util.LinkedHashMap;
    77import java.util.List;
    88import java.util.Map;
     9import java.util.SortedMap;
    910
    1011/**
    1112 * Setting containing a {@link List} of {@link Map}s of {@link String} values.
    … …  
    4041        if (value.contains(null))
    4142            throw new IllegalArgumentException("Error: Null as list element in preference setting");
    4243        for (Map<String, String> map : value) {
    43             if (map.containsKey(null))
     44            if (!(map instanceof SortedMap) && map.containsKey(null))
    4445                throw new IllegalArgumentException("Error: Null as map key in preference setting");
    4546            if (map.containsValue(null))
    4647                throw new IllegalArgumentException("Error: Null as map value in preference setting");