Ticket #8933: external_update.patch

File external_update.patch, 22.0 KB (added by taylor.smock, 7 years ago)

Refactor the preferences pane to have a generic update panel (plugin updates still work, now there are options for (unimplemented) updates for validators, should be easy to copy over to the mappaint styles).

  • src/org/openstreetmap/josm/gui/preferences/plugin/PluginUpdatePolicyPanel.java

     
    1 // License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.gui.preferences.plugin;
    3 
    4 import static org.openstreetmap.josm.tools.I18n.tr;
    5 
    6 import java.awt.FlowLayout;
    7 import java.awt.GridBagConstraints;
    8 import java.awt.GridBagLayout;
    9 import java.awt.Insets;
    10 import java.util.EnumMap;
    11 import java.util.Locale;
    12 import java.util.Map;
    13 import java.util.Optional;
    14 
    15 import javax.swing.ButtonGroup;
    16 import javax.swing.JLabel;
    17 import javax.swing.JPanel;
    18 import javax.swing.JRadioButton;
    19 import javax.swing.event.ChangeEvent;
    20 import javax.swing.event.ChangeListener;
    21 
    22 import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    23 import org.openstreetmap.josm.gui.widgets.JosmTextField;
    24 import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    25 import org.openstreetmap.josm.plugins.PluginHandler;
    26 import org.openstreetmap.josm.spi.preferences.Config;
    27 
    28 /**
    29  * A panel for configuring whether JOSM shall update plugins at startup.
    30  *
    31  */
    32 public class PluginUpdatePolicyPanel extends JPanel {
    33 
    34     private enum Policy {
    35         ASK("ask"),
    36         ALWAYS("always"),
    37         NEVER("never");
    38 
    39         private final String preferenceValue;
    40 
    41         Policy(String preferenceValue) {
    42             this.preferenceValue = preferenceValue;
    43         }
    44 
    45         public String getPreferencesValue() {
    46             return preferenceValue;
    47         }
    48 
    49         static Policy fromPreferenceValue(String preferenceValue) {
    50             if (preferenceValue == null)
    51                 return null;
    52             String prefValue = preferenceValue.trim().toLowerCase(Locale.ENGLISH);
    53             for (Policy p: Policy.values()) {
    54                 if (p.getPreferencesValue().equals(prefValue))
    55                     return p;
    56             }
    57             return null;
    58         }
    59     }
    60 
    61     private transient Map<Policy, JRadioButton> rbVersionBasedUpatePolicy;
    62     private transient Map<Policy, JRadioButton> rbTimeBasedUpatePolicy;
    63     private final JosmTextField tfUpdateInterval = new JosmTextField(5);
    64     private final JLabel lblUpdateInterval = new JLabel(tr("Update interval (in days):"));
    65 
    66     /**
    67      * Constructs a new {@code PluginUpdatePolicyPanel}.
    68      */
    69     public PluginUpdatePolicyPanel() {
    70         build();
    71         initFromPreferences();
    72     }
    73 
    74     protected JPanel buildVersionBasedUpdatePolicyPanel() {
    75         JPanel pnl = new JPanel(new GridBagLayout());
    76         GridBagConstraints gc = new GridBagConstraints();
    77         gc.anchor = GridBagConstraints.NORTHWEST;
    78         gc.fill = GridBagConstraints.HORIZONTAL;
    79         gc.weightx = 1.0;
    80 
    81         ButtonGroup bgVersionBasedUpdatePolicy = new ButtonGroup();
    82         rbVersionBasedUpatePolicy = new EnumMap<>(Policy.class);
    83         JRadioButton btn = new JRadioButton(tr("Ask before updating"));
    84         rbVersionBasedUpatePolicy.put(Policy.ASK, btn);
    85         bgVersionBasedUpdatePolicy.add(btn);
    86 
    87         btn = new JRadioButton(tr("Always update without asking"));
    88         rbVersionBasedUpatePolicy.put(Policy.ALWAYS, btn);
    89         bgVersionBasedUpdatePolicy.add(btn);
    90 
    91         btn = new JRadioButton(tr("Never update"));
    92         rbVersionBasedUpatePolicy.put(Policy.NEVER, btn);
    93         bgVersionBasedUpdatePolicy.add(btn);
    94 
    95         JMultilineLabel lbl = new JMultilineLabel(
    96                 tr("Please decide whether JOSM shall automatically update active plugins at startup after an update of JOSM itself."));
    97         gc.gridy = 0;
    98         pnl.add(lbl, gc);
    99         for (Policy p: Policy.values()) {
    100             gc.gridy++;
    101             pnl.add(rbVersionBasedUpatePolicy.get(p), gc);
    102         }
    103         return pnl;
    104     }
    105 
    106     protected JPanel buildUpdateIntervalPanel() {
    107         JPanel pnl = new JPanel(new FlowLayout(FlowLayout.LEFT));
    108         pnl.add(lblUpdateInterval);
    109         pnl.add(tfUpdateInterval);
    110         lblUpdateInterval.setLabelFor(tfUpdateInterval);
    111         SelectAllOnFocusGainedDecorator.decorate(tfUpdateInterval);
    112         return pnl;
    113     }
    114 
    115     protected JPanel buildTimeBasedUpdatePolicyPanel() {
    116         JPanel pnl = new JPanel(new GridBagLayout());
    117         GridBagConstraints gc = new GridBagConstraints();
    118         gc.anchor = GridBagConstraints.NORTHWEST;
    119         gc.fill = GridBagConstraints.HORIZONTAL;
    120         gc.weightx = 1.0;
    121 
    122         TimeBasedPolicyChangeListener changeListener = new TimeBasedPolicyChangeListener();
    123 
    124         ButtonGroup bgTimeBasedUpdatePolicy = new ButtonGroup();
    125         rbTimeBasedUpatePolicy = new EnumMap<>(Policy.class);
    126         JRadioButton btn = new JRadioButton(tr("Ask before updating"));
    127         btn.addChangeListener(changeListener);
    128         rbTimeBasedUpatePolicy.put(Policy.ASK, btn);
    129         bgTimeBasedUpdatePolicy.add(btn);
    130 
    131         btn = new JRadioButton(tr("Always update without asking"));
    132         btn.addChangeListener(changeListener);
    133         rbTimeBasedUpatePolicy.put(Policy.ALWAYS, btn);
    134         bgTimeBasedUpdatePolicy.add(btn);
    135 
    136         btn = new JRadioButton(tr("Never update"));
    137         btn.addChangeListener(changeListener);
    138         rbTimeBasedUpatePolicy.put(Policy.NEVER, btn);
    139         bgTimeBasedUpdatePolicy.add(btn);
    140 
    141         JMultilineLabel lbl = new JMultilineLabel(
    142                 tr("Please decide whether JOSM shall automatically update active plugins after a certain period of time."));
    143         gc.gridy = 0;
    144         pnl.add(lbl, gc);
    145         for (Policy p: Policy.values()) {
    146             gc.gridy++;
    147             pnl.add(rbTimeBasedUpatePolicy.get(p), gc);
    148         }
    149         gc.gridy++;
    150         pnl.add(buildUpdateIntervalPanel(), gc);
    151         return pnl;
    152     }
    153 
    154     protected final void build() {
    155         setLayout(new GridBagLayout());
    156         GridBagConstraints gc = new GridBagConstraints();
    157         gc.anchor = GridBagConstraints.NORTHWEST;
    158         gc.fill = GridBagConstraints.HORIZONTAL;
    159         gc.weightx = 1.0;
    160         gc.insets = new Insets(5, 5, 10, 5);
    161 
    162         add(buildVersionBasedUpdatePolicyPanel(), gc);
    163         gc.gridy = 1;
    164         add(buildTimeBasedUpdatePolicyPanel(), gc);
    165 
    166         gc.gridy = 2;
    167         gc.weighty = 1.0;
    168         gc.fill = GridBagConstraints.BOTH;
    169         add(new JPanel(), gc);
    170     }
    171 
    172     /**
    173      * Loads the relevant preference values from the JOSM preferences
    174      */
    175     public final void initFromPreferences() {
    176         rbVersionBasedUpatePolicy.get(
    177                 Optional.ofNullable(Policy.fromPreferenceValue(
    178                         Config.getPref().get("pluginmanager.version-based-update.policy", "ask"))).orElse(Policy.ASK))
    179                 .setSelected(true);
    180         rbTimeBasedUpatePolicy.get(
    181                 Optional.ofNullable(Policy.fromPreferenceValue(
    182                         Config.getPref().get("pluginmanager.time-based-update.policy", "ask"))).orElse(Policy.ASK))
    183                 .setSelected(true);
    184 
    185         int days = Config.getPref().getInt("pluginmanager.time-based-update.interval", PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL);
    186         tfUpdateInterval.setText(Integer.toString(days));
    187     }
    188 
    189     /**
    190      * Remebers the update policy preference settings on the JOSM preferences
    191      */
    192     public void rememberInPreferences() {
    193 
    194         // remember policy for version based update
    195         //
    196         for (Policy p: Policy.values()) {
    197             if (rbVersionBasedUpatePolicy.get(p).isSelected()) {
    198                 Config.getPref().put("pluginmanager.version-based-update.policy", p.getPreferencesValue());
    199                 break;
    200             }
    201         }
    202 
    203         // remember policy for time based update
    204         //
    205         for (Policy p: Policy.values()) {
    206             if (rbTimeBasedUpatePolicy.get(p).isSelected()) {
    207                 Config.getPref().put("pluginmanager.time-based-update.policy", p.getPreferencesValue());
    208                 break;
    209             }
    210         }
    211 
    212         // remember update interval
    213         //
    214         int days = 0;
    215         try {
    216             days = Integer.parseInt(tfUpdateInterval.getText().trim());
    217             if (days <= 0) {
    218                 days = PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL;
    219             }
    220         } catch (NumberFormatException e) {
    221             days = PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL;
    222         }
    223         Config.getPref().putInt("pluginmanager.time-based-update.interval", days);
    224     }
    225 
    226     class TimeBasedPolicyChangeListener implements ChangeListener {
    227         @Override
    228         public void stateChanged(ChangeEvent e) {
    229             lblUpdateInterval.setEnabled(!rbTimeBasedUpatePolicy.get(Policy.NEVER).isSelected());
    230             tfUpdateInterval.setEnabled(!rbTimeBasedUpatePolicy.get(Policy.NEVER).isSelected());
    231         }
    232     }
    233 
    234 }

  • src/org/openstreetmap/josm/gui/preferences/UpdatePolicyPanel.java 

    Property changes on: src/org/openstreetmap/josm/gui/preferences/plugin/PluginUpdatePolicyPanel.java
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
     
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.gui.preferences;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
     5
     6import java.awt.FlowLayout;
     7import java.awt.GridBagConstraints;
     8import java.awt.GridBagLayout;
     9import java.awt.Insets;
     10import java.util.EnumMap;
     11import java.util.Locale;
     12import java.util.Map;
     13import java.util.Optional;
     14
     15import javax.swing.ButtonGroup;
     16import javax.swing.JLabel;
     17import javax.swing.JPanel;
     18import javax.swing.JRadioButton;
     19import javax.swing.event.ChangeEvent;
     20import javax.swing.event.ChangeListener;
     21
     22import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     23import org.openstreetmap.josm.gui.widgets.JosmTextField;
     24import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
     25import org.openstreetmap.josm.plugins.PluginHandler;
     26import org.openstreetmap.josm.spi.preferences.Config;
     27
     28/**
     29 * An abstract method to implement update panels
     30 * @author Taylor Smock
     31 * @since xxx
     32 */
     33public class UpdatePolicyPanel extends JPanel {
     34    private enum Policy {
     35        ASK("ask"),
     36        ALWAYS("always"),
     37        NEVER("never");
     38
     39        private final String preferenceValue;
     40
     41        Policy(String preferenceValue) {
     42            this.preferenceValue = preferenceValue;
     43        }
     44
     45        public String getPreferencesValue() {
     46            return preferenceValue;
     47        }
     48
     49        static Policy fromPreferenceValue(String preferenceValue) {
     50            if (preferenceValue == null)
     51                return null;
     52            String prefValue = preferenceValue.trim().toLowerCase(Locale.ENGLISH);
     53            for (Policy p: Policy.values()) {
     54                if (p.getPreferencesValue().equals(prefValue))
     55                    return p;
     56            }
     57            return null;
     58        }
     59    }
     60
     61    private transient Map<Policy, JRadioButton> rbVersionBasedUpatePolicy;
     62    private transient Map<Policy, JRadioButton> rbTimeBasedUpatePolicy;
     63    private final JosmTextField tfUpdateInterval = new JosmTextField(5);
     64    private final JLabel lblUpdateInterval = new JLabel(tr("Update interval (in days):"));
     65    private final String type;
     66
     67    /**
     68     * Constructs a new {@code UpdatePolicyPanel}.
     69     * @param type The type of external file to update (plugin, validator, map paint style)
     70     */
     71    public UpdatePolicyPanel(String type) {
     72        this.type = type;
     73        build();
     74        initFromPreferences();
     75    }
     76
     77    /*
     78     * Prevent empty super()
     79     */
     80    @SuppressWarnings("unused")
     81    private UpdatePolicyPanel() {
     82        this.type = null;
     83        // Do nothing
     84    }
     85
     86    protected JPanel buildVersionBasedUpdatePolicyPanel() {
     87        JPanel pnl = new JPanel(new GridBagLayout());
     88        GridBagConstraints gc = new GridBagConstraints();
     89        gc.anchor = GridBagConstraints.NORTHWEST;
     90        gc.fill = GridBagConstraints.HORIZONTAL;
     91        gc.weightx = 1.0;
     92
     93        ButtonGroup bgVersionBasedUpdatePolicy = new ButtonGroup();
     94        rbVersionBasedUpatePolicy = new EnumMap<>(Policy.class);
     95        JRadioButton btn = new JRadioButton(tr("Ask before updating"));
     96        rbVersionBasedUpatePolicy.put(Policy.ASK, btn);
     97        bgVersionBasedUpdatePolicy.add(btn);
     98
     99        btn = new JRadioButton(tr("Always update without asking"));
     100        rbVersionBasedUpatePolicy.put(Policy.ALWAYS, btn);
     101        bgVersionBasedUpdatePolicy.add(btn);
     102
     103        btn = new JRadioButton(tr("Never update"));
     104        rbVersionBasedUpatePolicy.put(Policy.NEVER, btn);
     105        bgVersionBasedUpdatePolicy.add(btn);
     106
     107        JMultilineLabel lbl = new JMultilineLabel(
     108                tr("Please decide whether JOSM shall automatically update active " + type + "s at startup after an update of JOSM itself."));
     109        gc.gridy = 0;
     110        pnl.add(lbl, gc);
     111        for (Policy p: Policy.values()) {
     112            gc.gridy++;
     113            pnl.add(rbVersionBasedUpatePolicy.get(p), gc);
     114        }
     115        return pnl;
     116    }
     117
     118    protected JPanel buildUpdateIntervalPanel() {
     119        JPanel pnl = new JPanel(new FlowLayout(FlowLayout.LEFT));
     120        pnl.add(lblUpdateInterval);
     121        pnl.add(tfUpdateInterval);
     122        lblUpdateInterval.setLabelFor(tfUpdateInterval);
     123        SelectAllOnFocusGainedDecorator.decorate(tfUpdateInterval);
     124        return pnl;
     125    }
     126
     127    protected JPanel buildTimeBasedUpdatePolicyPanel() {
     128        JPanel pnl = new JPanel(new GridBagLayout());
     129        GridBagConstraints gc = new GridBagConstraints();
     130        gc.anchor = GridBagConstraints.NORTHWEST;
     131        gc.fill = GridBagConstraints.HORIZONTAL;
     132        gc.weightx = 1.0;
     133
     134        TimeBasedPolicyChangeListener changeListener = new TimeBasedPolicyChangeListener();
     135
     136        ButtonGroup bgTimeBasedUpdatePolicy = new ButtonGroup();
     137        rbTimeBasedUpatePolicy = new EnumMap<>(Policy.class);
     138        JRadioButton btn = new JRadioButton(tr("Ask before updating"));
     139        btn.addChangeListener(changeListener);
     140        rbTimeBasedUpatePolicy.put(Policy.ASK, btn);
     141        bgTimeBasedUpdatePolicy.add(btn);
     142
     143        btn = new JRadioButton(tr("Always update without asking"));
     144        btn.addChangeListener(changeListener);
     145        rbTimeBasedUpatePolicy.put(Policy.ALWAYS, btn);
     146        bgTimeBasedUpdatePolicy.add(btn);
     147
     148        btn = new JRadioButton(tr("Never update"));
     149        btn.addChangeListener(changeListener);
     150        rbTimeBasedUpatePolicy.put(Policy.NEVER, btn);
     151        bgTimeBasedUpdatePolicy.add(btn);
     152
     153        JMultilineLabel lbl = new JMultilineLabel(
     154                tr("Please decide whether JOSM shall automatically update active " + type + "s after a certain period of time."));
     155        gc.gridy = 0;
     156        pnl.add(lbl, gc);
     157        for (Policy p: Policy.values()) {
     158            gc.gridy++;
     159            pnl.add(rbTimeBasedUpatePolicy.get(p), gc);
     160        }
     161        gc.gridy++;
     162        pnl.add(buildUpdateIntervalPanel(), gc);
     163        return pnl;
     164    }
     165
     166    protected final void build() {
     167        setLayout(new GridBagLayout());
     168        GridBagConstraints gc = new GridBagConstraints();
     169        gc.anchor = GridBagConstraints.NORTHWEST;
     170        gc.fill = GridBagConstraints.HORIZONTAL;
     171        gc.weightx = 1.0;
     172        gc.insets = new Insets(5, 5, 10, 5);
     173
     174        add(buildVersionBasedUpdatePolicyPanel(), gc);
     175        gc.gridy = 1;
     176        add(buildTimeBasedUpdatePolicyPanel(), gc);
     177
     178        gc.gridy = 2;
     179        gc.weighty = 1.0;
     180        gc.fill = GridBagConstraints.BOTH;
     181        add(new JPanel(), gc);
     182    }
     183
     184    /**
     185     * Loads the relevant preference values from the JOSM preferences
     186     */
     187    public final void initFromPreferences() {
     188        rbVersionBasedUpatePolicy.get(
     189                Optional.ofNullable(Policy.fromPreferenceValue(
     190                        Config.getPref().get(type + "manager.version-based-update.policy", "ask"))).orElse(Policy.ASK))
     191                .setSelected(true);
     192        rbTimeBasedUpatePolicy.get(
     193                Optional.ofNullable(Policy.fromPreferenceValue(
     194                        Config.getPref().get(type + "manager.time-based-update.policy", "ask"))).orElse(Policy.ASK))
     195                .setSelected(true);
     196
     197        int days = Config.getPref().getInt(type + "manager.time-based-update.interval", PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL);
     198        tfUpdateInterval.setText(Integer.toString(days));
     199    }
     200
     201    /**
     202     * Remembers the update policy preference settings on the JOSM preferences
     203     */
     204    public void rememberInPreferences() {
     205
     206        // remember policy for version based update
     207        //
     208        for (Policy p: Policy.values()) {
     209            if (rbVersionBasedUpatePolicy.get(p).isSelected()) {
     210                Config.getPref().put(type + "manager.version-based-update.policy", p.getPreferencesValue());
     211                break;
     212            }
     213        }
     214
     215        // remember policy for time based update
     216        //
     217        for (Policy p: Policy.values()) {
     218            if (rbTimeBasedUpatePolicy.get(p).isSelected()) {
     219                Config.getPref().put(type + "manager.time-based-update.policy", p.getPreferencesValue());
     220                break;
     221            }
     222        }
     223
     224        // remember update interval
     225        //
     226        int days = 0;
     227        try {
     228            days = Integer.parseInt(tfUpdateInterval.getText().trim());
     229            if (days <= 0) {
     230                days = PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL;
     231            }
     232        } catch (NumberFormatException e) {
     233            days = PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL;
     234        }
     235        Config.getPref().putInt(type + "manager.time-based-update.interval", days);
     236    }
     237
     238    class TimeBasedPolicyChangeListener implements ChangeListener {
     239        @Override
     240        public void stateChanged(ChangeEvent e) {
     241            lblUpdateInterval.setEnabled(!rbTimeBasedUpatePolicy.get(Policy.NEVER).isSelected());
     242            tfUpdateInterval.setEnabled(!rbTimeBasedUpatePolicy.get(Policy.NEVER).isSelected());
     243        }
     244    }
     245}

  • src/org/openstreetmap/josm/gui/preferences/plugin/PluginPreference.java

     
    5454import org.openstreetmap.josm.gui.preferences.PreferenceSettingFactory;
    5555import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane;
    5656import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane.PreferencePanel;
     57import org.openstreetmap.josm.gui.preferences.UpdatePolicyPanel;
    5758import org.openstreetmap.josm.gui.util.GuiHelper;
    5859import org.openstreetmap.josm.gui.widgets.JosmTextField;
    5960import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    … …  
    8788    private PluginListPanel pnlPluginPreferences;
    8889    private PluginPreferencesModel model;
    8990    private JScrollPane spPluginPreferences;
    90     private PluginUpdatePolicyPanel pnlPluginUpdatePolicy;
     91    private UpdatePolicyPanel pnlPluginUpdatePolicy;
    9192
    9293    /**
    9394     * is set to true if this preference pane has been selected by the user
    … …  
    251252
    252253    private JTabbedPane buildContentPane() {
    253254        JTabbedPane pane = getTabPane();
    254         pnlPluginUpdatePolicy = new PluginUpdatePolicyPanel();
     255        pnlPluginUpdatePolicy = new UpdatePolicyPanel("plugin");
    255256        pane.addTab(tr("Plugins"), buildPluginListPanel());
    256257        pane.addTab(tr("Plugin update policy"), pnlPluginUpdatePolicy);
    257258        return pane;

  • src/org/openstreetmap/josm/gui/preferences/validator/ValidatorTagCheckerRulesPreference.java

     
    99import java.util.Collections;
    1010import java.util.List;
    1111
     12import javax.swing.JTabbedPane;
     13
    1214import org.openstreetmap.josm.data.preferences.sources.ExtendedSourceEntry;
    1315import org.openstreetmap.josm.data.preferences.sources.SourceEntry;
    1416import org.openstreetmap.josm.data.preferences.sources.SourceProvider;
    … …  
    2224import org.openstreetmap.josm.gui.preferences.SourceEditor;
    2325import org.openstreetmap.josm.gui.preferences.SubPreferenceSetting;
    2426import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
     27import org.openstreetmap.josm.gui.preferences.UpdatePolicyPanel;
    2528import org.openstreetmap.josm.gui.preferences.map.MapPaintPreference;
    2629import org.openstreetmap.josm.spi.preferences.Config;
    2730
    … …  
    4245    }
    4346
    4447    private static final List<SourceProvider> ruleSourceProviders = new ArrayList<>();
     48    private UpdatePolicyPanel vupp;
     49    private boolean validatorPreferencesActivated = false;
    4550
    4651    /**
    4752     * Registers a new additional rule source provider.
    … …  
    130135
    131136        valPref.addSubTab(this, tr("Tag checker rules"),
    132137                sources, tr("Choose Tag checker rules to enable"));
     138        vupp = new UpdatePolicyPanel("validator");
     139        JTabbedPane pane = valPref.getTabPane();
     140        pane.addTab(tr("Tag checker update policy"), vupp);
    133141        sources.deferLoading(valPref, sources);
     142        validatorPreferencesActivated = true;
    134143    }
    135144
    136145    @Override
    … …  
    142151                OsmValidator.initializeTests(Collections.singleton(tagChecker));
    143152            }
    144153        }
    145 
     154        if (validatorPreferencesActivated) {
     155            vupp.rememberInPreferences();
     156        }
    146157        return false;
    147158    }
    148159