source: josm/trunk/src/org/openstreetmap/josm/data/Preferences.java @ 12306

Last change on this file since 12306 was 12306, checked in by bastiK, 21 months ago

fixed #14877 - make projection setting transient

  • Property svn:eol-style set to native
File size: 62.3 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data;
3
4import static org.openstreetmap.josm.tools.I18n.marktr;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.Color;
8import java.awt.GraphicsEnvironment;
9import java.awt.Toolkit;
10import java.io.File;
11import java.io.IOException;
12import java.io.PrintWriter;
13import java.io.Reader;
14import java.io.StringReader;
15import java.io.StringWriter;
16import java.lang.annotation.Retention;
17import java.lang.annotation.RetentionPolicy;
18import java.lang.reflect.Field;
19import java.nio.charset.StandardCharsets;
20import java.util.AbstractMap;
21import java.util.ArrayList;
22import java.util.Collection;
23import java.util.Collections;
24import java.util.HashMap;
25import java.util.HashSet;
26import java.util.Iterator;
27import java.util.LinkedHashMap;
28import java.util.LinkedList;
29import java.util.List;
30import java.util.Map;
31import java.util.Map.Entry;
32import java.util.Objects;
33import java.util.Optional;
34import java.util.ResourceBundle;
35import java.util.Set;
36import java.util.SortedMap;
37import java.util.TreeMap;
38import java.util.concurrent.TimeUnit;
39import java.util.function.Predicate;
40import java.util.regex.Matcher;
41import java.util.regex.Pattern;
42import java.util.stream.Collectors;
43import java.util.stream.Stream;
44
45import javax.json.Json;
46import javax.json.JsonArray;
47import javax.json.JsonArrayBuilder;
48import javax.json.JsonObject;
49import javax.json.JsonObjectBuilder;
50import javax.json.JsonReader;
51import javax.json.JsonString;
52import javax.json.JsonValue;
53import javax.json.JsonWriter;
54import javax.swing.JOptionPane;
55import javax.xml.stream.XMLStreamException;
56
57import org.openstreetmap.josm.Main;
58import org.openstreetmap.josm.data.preferences.BooleanProperty;
59import org.openstreetmap.josm.data.preferences.ColorProperty;
60import org.openstreetmap.josm.data.preferences.DoubleProperty;
61import org.openstreetmap.josm.data.preferences.IntegerProperty;
62import org.openstreetmap.josm.data.preferences.ListListSetting;
63import org.openstreetmap.josm.data.preferences.ListSetting;
64import org.openstreetmap.josm.data.preferences.LongProperty;
65import org.openstreetmap.josm.data.preferences.MapListSetting;
66import org.openstreetmap.josm.data.preferences.PreferencesReader;
67import org.openstreetmap.josm.data.preferences.PreferencesWriter;
68import org.openstreetmap.josm.data.preferences.Setting;
69import org.openstreetmap.josm.data.preferences.StringSetting;
70import org.openstreetmap.josm.gui.preferences.SourceEditor.ExtendedSourceEntry;
71import org.openstreetmap.josm.gui.preferences.validator.ValidatorTagCheckerRulesPreference;
72import org.openstreetmap.josm.gui.preferences.validator.ValidatorTagCheckerRulesPreference.RulePrefHelper;
73import org.openstreetmap.josm.io.OfflineAccessException;
74import org.openstreetmap.josm.io.OnlineResource;
75import org.openstreetmap.josm.tools.CheckParameterUtil;
76import org.openstreetmap.josm.tools.ColorHelper;
77import org.openstreetmap.josm.tools.I18n;
78import org.openstreetmap.josm.tools.JosmRuntimeException;
79import org.openstreetmap.josm.tools.ListenerList;
80import org.openstreetmap.josm.tools.MultiMap;
81import org.openstreetmap.josm.tools.Utils;
82import org.xml.sax.SAXException;
83
84/**
85 * This class holds all preferences for JOSM.
86 *
87 * Other classes can register their beloved properties here. All properties will be
88 * saved upon set-access.
89 *
90 * Each property is a key=setting pair, where key is a String and setting can be one of
91 * 4 types:
92 *     string, list, list of lists and list of maps.
93 * In addition, each key has a unique default value that is set when the value is first
94 * accessed using one of the get...() methods. You can use the same preference
95 * key in different parts of the code, but the default value must be the same
96 * everywhere. A default value of null means, the setting has been requested, but
97 * no default value was set. This is used in advanced preferences to present a list
98 * off all possible settings.
99 *
100 * At the moment, you cannot put the empty string for string properties.
101 * put(key, "") means, the property is removed.
102 *
103 * @author imi
104 * @since 74
105 */
106public class Preferences {
107
108    private static final String COLOR_PREFIX = "color.";
109
110    private static final String[] OBSOLETE_PREF_KEYS = {
111      "imagery.layers.addedIds", /* remove entry after June 2017 */
112      "projection", /* remove entry after Nov. 2017 */
113      "projection.sub", /* remove entry after Nov. 2017 */
114    };
115
116    private static final long MAX_AGE_DEFAULT_PREFERENCES = TimeUnit.DAYS.toSeconds(50);
117
118    /**
119     * Internal storage for the preference directory.
120     * Do not access this variable directly!
121     * @see #getPreferencesDirectory()
122     */
123    private File preferencesDir;
124
125    /**
126     * Internal storage for the cache directory.
127     */
128    private File cacheDir;
129
130    /**
131     * Internal storage for the user data directory.
132     */
133    private File userdataDir;
134
135    /**
136     * Determines if preferences file is saved each time a property is changed.
137     */
138    private boolean saveOnPut = true;
139
140    /**
141     * Maps the setting name to the current value of the setting.
142     * The map must not contain null as key or value. The mapped setting objects
143     * must not have a null value.
144     */
145    protected final SortedMap<String, Setting<?>> settingsMap = new TreeMap<>();
146
147    /**
148     * Maps the setting name to the default value of the setting.
149     * The map must not contain null as key or value. The value of the mapped
150     * setting objects can be null.
151     */
152    protected final SortedMap<String, Setting<?>> defaultsMap = new TreeMap<>();
153
154    private final Predicate<Entry<String, Setting<?>>> NO_DEFAULT_SETTINGS_ENTRY =
155            e -> !e.getValue().equals(defaultsMap.get(e.getKey()));
156
157    /**
158     * Maps color keys to human readable color name
159     */
160    protected final SortedMap<String, String> colornames = new TreeMap<>();
161
162    /**
163     * Indicates whether {@link #init(boolean)} completed successfully.
164     * Used to decide whether to write backup preference file in {@link #save()}
165     */
166    protected boolean initSuccessful;
167
168    /**
169     * Event triggered when a preference entry value changes.
170     */
171    public interface PreferenceChangeEvent {
172        /**
173         * Returns the preference key.
174         * @return the preference key
175         */
176        String getKey();
177
178        /**
179         * Returns the old preference value.
180         * @return the old preference value
181         */
182        Setting<?> getOldValue();
183
184        /**
185         * Returns the new preference value.
186         * @return the new preference value
187         */
188        Setting<?> getNewValue();
189    }
190
191    /**
192     * Listener to preference change events.
193     * @since 10600 (functional interface)
194     */
195    @FunctionalInterface
196    public interface PreferenceChangedListener {
197        /**
198         * Trigerred when a preference entry value changes.
199         * @param e the preference change event
200         */
201        void preferenceChanged(PreferenceChangeEvent e);
202    }
203
204    private static class DefaultPreferenceChangeEvent implements PreferenceChangeEvent {
205        private final String key;
206        private final Setting<?> oldValue;
207        private final Setting<?> newValue;
208
209        DefaultPreferenceChangeEvent(String key, Setting<?> oldValue, Setting<?> newValue) {
210            this.key = key;
211            this.oldValue = oldValue;
212            this.newValue = newValue;
213        }
214
215        @Override
216        public String getKey() {
217            return key;
218        }
219
220        @Override
221        public Setting<?> getOldValue() {
222            return oldValue;
223        }
224
225        @Override
226        public Setting<?> getNewValue() {
227            return newValue;
228        }
229    }
230
231    private final ListenerList<PreferenceChangedListener> listeners = ListenerList.create();
232
233    private final HashMap<String, ListenerList<PreferenceChangedListener>> keyListeners = new HashMap<>();
234
235    /**
236     * Adds a new preferences listener.
237     * @param listener The listener to add
238     */
239    public void addPreferenceChangeListener(PreferenceChangedListener listener) {
240        if (listener != null) {
241            listeners.addListener(listener);
242        }
243    }
244
245    /**
246     * Removes a preferences listener.
247     * @param listener The listener to remove
248     */
249    public void removePreferenceChangeListener(PreferenceChangedListener listener) {
250        listeners.removeListener(listener);
251    }
252
253    /**
254     * Adds a listener that only listens to changes in one preference
255     * @param key The preference key to listen to
256     * @param listener The listener to add.
257     * @since 10824
258     */
259    public void addKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
260        listenersForKey(key).addListener(listener);
261    }
262
263    /**
264     * Adds a weak listener that only listens to changes in one preference
265     * @param key The preference key to listen to
266     * @param listener The listener to add.
267     * @since 10824
268     */
269    public void addWeakKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
270        listenersForKey(key).addWeakListener(listener);
271    }
272
273    private ListenerList<PreferenceChangedListener> listenersForKey(String key) {
274        ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
275        if (keyListener == null) {
276            keyListener = ListenerList.create();
277            keyListeners.put(key, keyListener);
278        }
279        return keyListener;
280    }
281
282    /**
283     * Removes a listener that only listens to changes in one preference
284     * @param key The preference key to listen to
285     * @param listener The listener to add.
286     */
287    public void removeKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
288        Optional.ofNullable(keyListeners.get(key)).orElseThrow(
289                () -> new IllegalArgumentException("There are no listeners registered for " + key))
290        .removeListener(listener);
291    }
292
293    protected void firePreferenceChanged(String key, Setting<?> oldValue, Setting<?> newValue) {
294        final PreferenceChangeEvent evt = new DefaultPreferenceChangeEvent(key, oldValue, newValue);
295        listeners.fireEvent(listener -> listener.preferenceChanged(evt));
296
297        ListenerList<PreferenceChangedListener> forKey = keyListeners.get(key);
298        if (forKey != null) {
299            forKey.fireEvent(listener -> listener.preferenceChanged(evt));
300        }
301    }
302
303    /**
304     * Get the base name of the JOSM directories for preferences, cache and
305     * user data.
306     * Default value is "JOSM", unless overridden by system property "josm.dir.name".
307     * @return the base name of the JOSM directories for preferences, cache and
308     * user data
309     */
310    public String getJOSMDirectoryBaseName() {
311        String name = System.getProperty("josm.dir.name");
312        if (name != null)
313            return name;
314        else
315            return "JOSM";
316    }
317
318    /**
319     * Returns the user defined preferences directory, containing the preferences.xml file
320     * @return The user defined preferences directory, containing the preferences.xml file
321     * @since 7834
322     */
323    public File getPreferencesDirectory() {
324        if (preferencesDir != null)
325            return preferencesDir;
326        String path;
327        path = System.getProperty("josm.pref");
328        if (path != null) {
329            preferencesDir = new File(path).getAbsoluteFile();
330        } else {
331            path = System.getProperty("josm.home");
332            if (path != null) {
333                preferencesDir = new File(path).getAbsoluteFile();
334            } else {
335                preferencesDir = Main.platform.getDefaultPrefDirectory();
336            }
337        }
338        return preferencesDir;
339    }
340
341    /**
342     * Returns the user data directory, containing autosave, plugins, etc.
343     * Depending on the OS it may be the same directory as preferences directory.
344     * @return The user data directory, containing autosave, plugins, etc.
345     * @since 7834
346     */
347    public File getUserDataDirectory() {
348        if (userdataDir != null)
349            return userdataDir;
350        String path;
351        path = System.getProperty("josm.userdata");
352        if (path != null) {
353            userdataDir = new File(path).getAbsoluteFile();
354        } else {
355            path = System.getProperty("josm.home");
356            if (path != null) {
357                userdataDir = new File(path).getAbsoluteFile();
358            } else {
359                userdataDir = Main.platform.getDefaultUserDataDirectory();
360            }
361        }
362        return userdataDir;
363    }
364
365    /**
366     * Returns the user preferences file (preferences.xml).
367     * @return The user preferences file (preferences.xml)
368     */
369    public File getPreferenceFile() {
370        return new File(getPreferencesDirectory(), "preferences.xml");
371    }
372
373    /**
374     * Returns the cache file for default preferences.
375     * @return the cache file for default preferences
376     */
377    public File getDefaultsCacheFile() {
378        return new File(getCacheDirectory(), "default_preferences.xml");
379    }
380
381    /**
382     * Returns the user plugin directory.
383     * @return The user plugin directory
384     */
385    public File getPluginsDirectory() {
386        return new File(getUserDataDirectory(), "plugins");
387    }
388
389    /**
390     * Get the directory where cached content of any kind should be stored.
391     *
392     * If the directory doesn't exist on the file system, it will be created by this method.
393     *
394     * @return the cache directory
395     */
396    public File getCacheDirectory() {
397        if (cacheDir != null)
398            return cacheDir;
399        String path = System.getProperty("josm.cache");
400        if (path != null) {
401            cacheDir = new File(path).getAbsoluteFile();
402        } else {
403            path = System.getProperty("josm.home");
404            if (path != null) {
405                cacheDir = new File(path, "cache");
406            } else {
407                path = get("cache.folder", null);
408                if (path != null) {
409                    cacheDir = new File(path).getAbsoluteFile();
410                } else {
411                    cacheDir = Main.platform.getDefaultCacheDirectory();
412                }
413            }
414        }
415        if (!cacheDir.exists() && !cacheDir.mkdirs()) {
416            Main.warn(tr("Failed to create missing cache directory: {0}", cacheDir.getAbsoluteFile()));
417            JOptionPane.showMessageDialog(
418                    Main.parent,
419                    tr("<html>Failed to create missing cache directory: {0}</html>", cacheDir.getAbsoluteFile()),
420                    tr("Error"),
421                    JOptionPane.ERROR_MESSAGE
422            );
423        }
424        return cacheDir;
425    }
426
427    private static void addPossibleResourceDir(Set<String> locations, String s) {
428        if (s != null) {
429            if (!s.endsWith(File.separator)) {
430                s += File.separator;
431            }
432            locations.add(s);
433        }
434    }
435
436    /**
437     * Returns a set of all existing directories where resources could be stored.
438     * @return A set of all existing directories where resources could be stored.
439     */
440    public Collection<String> getAllPossiblePreferenceDirs() {
441        Set<String> locations = new HashSet<>();
442        addPossibleResourceDir(locations, getPreferencesDirectory().getPath());
443        addPossibleResourceDir(locations, getUserDataDirectory().getPath());
444        addPossibleResourceDir(locations, System.getenv("JOSM_RESOURCES"));
445        addPossibleResourceDir(locations, System.getProperty("josm.resources"));
446        if (Main.isPlatformWindows()) {
447            String appdata = System.getenv("APPDATA");
448            if (appdata != null && System.getenv("ALLUSERSPROFILE") != null
449                    && appdata.lastIndexOf(File.separator) != -1) {
450                appdata = appdata.substring(appdata.lastIndexOf(File.separator));
451                locations.add(new File(new File(System.getenv("ALLUSERSPROFILE"),
452                        appdata), "JOSM").getPath());
453            }
454        } else {
455            locations.add("/usr/local/share/josm/");
456            locations.add("/usr/local/lib/josm/");
457            locations.add("/usr/share/josm/");
458            locations.add("/usr/lib/josm/");
459        }
460        return locations;
461    }
462
463    /**
464     * Get settings value for a certain key.
465     * @param key the identifier for the setting
466     * @return "" if there is nothing set for the preference key, the corresponding value otherwise. The result is not null.
467     */
468    public synchronized String get(final String key) {
469        String value = get(key, null);
470        return value == null ? "" : value;
471    }
472
473    /**
474     * Get settings value for a certain key and provide default a value.
475     * @param key the identifier for the setting
476     * @param def the default value. For each call of get() with a given key, the default value must be the same.
477     * @return the corresponding value if the property has been set before, {@code def} otherwise
478     */
479    public synchronized String get(final String key, final String def) {
480        return getSetting(key, new StringSetting(def), StringSetting.class).getValue();
481    }
482
483    public synchronized Map<String, String> getAllPrefix(final String prefix) {
484        final Map<String, String> all = new TreeMap<>();
485        for (final Entry<String, Setting<?>> e : settingsMap.entrySet()) {
486            if (e.getKey().startsWith(prefix) && (e.getValue() instanceof StringSetting)) {
487                all.put(e.getKey(), ((StringSetting) e.getValue()).getValue());
488            }
489        }
490        return all;
491    }
492
493    public synchronized List<String> getAllPrefixCollectionKeys(final String prefix) {
494        final List<String> all = new LinkedList<>();
495        for (Map.Entry<String, Setting<?>> entry : settingsMap.entrySet()) {
496            if (entry.getKey().startsWith(prefix) && entry.getValue() instanceof ListSetting) {
497                all.add(entry.getKey());
498            }
499        }
500        return all;
501    }
502
503    public synchronized Map<String, String> getAllColors() {
504        final Map<String, String> all = new TreeMap<>();
505        for (final Entry<String, Setting<?>> e : defaultsMap.entrySet()) {
506            if (e.getKey().startsWith(COLOR_PREFIX) && e.getValue() instanceof StringSetting) {
507                StringSetting d = (StringSetting) e.getValue();
508                if (d.getValue() != null) {
509                    all.put(e.getKey().substring(6), d.getValue());
510                }
511            }
512        }
513        for (final Entry<String, Setting<?>> e : settingsMap.entrySet()) {
514            if (e.getKey().startsWith(COLOR_PREFIX) && (e.getValue() instanceof StringSetting)) {
515                all.put(e.getKey().substring(6), ((StringSetting) e.getValue()).getValue());
516            }
517        }
518        return all;
519    }
520
521    public synchronized boolean getBoolean(final String key) {
522        String s = get(key, null);
523        return s != null && Boolean.parseBoolean(s);
524    }
525
526    public synchronized boolean getBoolean(final String key, final boolean def) {
527        return Boolean.parseBoolean(get(key, Boolean.toString(def)));
528    }
529
530    public synchronized boolean getBoolean(final String key, final String specName, final boolean def) {
531        boolean generic = getBoolean(key, def);
532        String skey = key+'.'+specName;
533        Setting<?> prop = settingsMap.get(skey);
534        if (prop instanceof StringSetting)
535            return Boolean.parseBoolean(((StringSetting) prop).getValue());
536        else
537            return generic;
538    }
539
540    /**
541     * Set a value for a certain setting.
542     * @param key the unique identifier for the setting
543     * @param value the value of the setting. Can be null or "" which both removes the key-value entry.
544     * @return {@code true}, if something has changed (i.e. value is different than before)
545     */
546    public boolean put(final String key, String value) {
547        return putSetting(key, value == null || value.isEmpty() ? null : new StringSetting(value));
548    }
549
550    /**
551     * Set a boolean value for a certain setting.
552     * @param key the unique identifier for the setting
553     * @param value The new value
554     * @return {@code true}, if something has changed (i.e. value is different than before)
555     * @see BooleanProperty
556     */
557    public boolean put(final String key, final boolean value) {
558        return put(key, Boolean.toString(value));
559    }
560
561    /**
562     * Set a boolean value for a certain setting.
563     * @param key the unique identifier for the setting
564     * @param value The new value
565     * @return {@code true}, if something has changed (i.e. value is different than before)
566     * @see IntegerProperty
567     */
568    public boolean putInteger(final String key, final Integer value) {
569        return put(key, Integer.toString(value));
570    }
571
572    /**
573     * Set a boolean value for a certain setting.
574     * @param key the unique identifier for the setting
575     * @param value The new value
576     * @return {@code true}, if something has changed (i.e. value is different than before)
577     * @see DoubleProperty
578     */
579    public boolean putDouble(final String key, final Double value) {
580        return put(key, Double.toString(value));
581    }
582
583    /**
584     * Set a boolean value for a certain setting.
585     * @param key the unique identifier for the setting
586     * @param value The new value
587     * @return {@code true}, if something has changed (i.e. value is different than before)
588     * @see LongProperty
589     */
590    public boolean putLong(final String key, final Long value) {
591        return put(key, Long.toString(value));
592    }
593
594    /**
595     * Called after every put. In case of a problem, do nothing but output the error in log.
596     * @throws IOException if any I/O error occurs
597     */
598    public synchronized void save() throws IOException {
599        save(getPreferenceFile(), settingsMap.entrySet().stream().filter(NO_DEFAULT_SETTINGS_ENTRY), false);
600    }
601
602    public synchronized void saveDefaults() throws IOException {
603        save(getDefaultsCacheFile(), defaultsMap.entrySet().stream(), true);
604    }
605
606    protected void save(File prefFile, Stream<Entry<String, Setting<?>>> settings, boolean defaults) throws IOException {
607        if (!defaults) {
608            /* currently unused, but may help to fix configuration issues in future */
609            putInteger("josm.version", Version.getInstance().getVersion());
610
611            updateSystemProperties();
612        }
613
614        File backupFile = new File(prefFile + "_backup");
615
616        // Backup old preferences if there are old preferences
617        if (initSuccessful && prefFile.exists() && prefFile.length() > 0) {
618            Utils.copyFile(prefFile, backupFile);
619        }
620
621        try (PreferencesWriter writer = new PreferencesWriter(
622                new PrintWriter(new File(prefFile + "_tmp"), StandardCharsets.UTF_8.name()), false, defaults)) {
623            writer.write(settings);
624        }
625
626        File tmpFile = new File(prefFile + "_tmp");
627        Utils.copyFile(tmpFile, prefFile);
628        Utils.deleteFile(tmpFile, marktr("Unable to delete temporary file {0}"));
629
630        setCorrectPermissions(prefFile);
631        setCorrectPermissions(backupFile);
632    }
633
634    private static void setCorrectPermissions(File file) {
635        if (!file.setReadable(false, false) && Main.isDebugEnabled()) {
636            Main.debug(tr("Unable to set file non-readable {0}", file.getAbsolutePath()));
637        }
638        if (!file.setWritable(false, false) && Main.isDebugEnabled()) {
639            Main.debug(tr("Unable to set file non-writable {0}", file.getAbsolutePath()));
640        }
641        if (!file.setExecutable(false, false) && Main.isDebugEnabled()) {
642            Main.debug(tr("Unable to set file non-executable {0}", file.getAbsolutePath()));
643        }
644        if (!file.setReadable(true, true) && Main.isDebugEnabled()) {
645            Main.debug(tr("Unable to set file readable {0}", file.getAbsolutePath()));
646        }
647        if (!file.setWritable(true, true) && Main.isDebugEnabled()) {
648            Main.debug(tr("Unable to set file writable {0}", file.getAbsolutePath()));
649        }
650    }
651
652    /**
653     * Loads preferences from settings file.
654     * @throws IOException if any I/O error occurs while reading the file
655     * @throws SAXException if the settings file does not contain valid XML
656     * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
657     */
658    protected void load() throws IOException, SAXException, XMLStreamException {
659        File pref = getPreferenceFile();
660        PreferencesReader.validateXML(pref);
661        PreferencesReader reader = new PreferencesReader(pref, false);
662        reader.parse();
663        settingsMap.clear();
664        settingsMap.putAll(reader.getSettings());
665        updateSystemProperties();
666        removeObsolete(reader.getVersion());
667    }
668
669    /**
670     * Loads default preferences from default settings cache file.
671     *
672     * Discards entries older than {@link #MAX_AGE_DEFAULT_PREFERENCES}.
673     *
674     * @throws IOException if any I/O error occurs while reading the file
675     * @throws SAXException if the settings file does not contain valid XML
676     * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
677     */
678    protected void loadDefaults() throws IOException, XMLStreamException, SAXException {
679        File def = getDefaultsCacheFile();
680        PreferencesReader.validateXML(def);
681        PreferencesReader reader = new PreferencesReader(def, true);
682        reader.parse();
683        defaultsMap.clear();
684        long minTime = System.currentTimeMillis() / 1000 - MAX_AGE_DEFAULT_PREFERENCES;
685        for (Entry<String, Setting<?>> e : reader.getSettings().entrySet()) {
686            if (e.getValue().getTime() >= minTime) {
687                defaultsMap.put(e.getKey(), e.getValue());
688            }
689        }
690    }
691
692    /**
693     * Loads preferences from XML reader.
694     * @param in XML reader
695     * @throws XMLStreamException if any XML stream error occurs
696     * @throws IOException if any I/O error occurs
697     */
698    public void fromXML(Reader in) throws XMLStreamException, IOException {
699        PreferencesReader reader = new PreferencesReader(in, false);
700        reader.parse();
701        settingsMap.clear();
702        settingsMap.putAll(reader.getSettings());
703    }
704
705    /**
706     * Initializes preferences.
707     * @param reset if {@code true}, current settings file is replaced by the default one
708     */
709    public void init(boolean reset) {
710        initSuccessful = false;
711        // get the preferences.
712        File prefDir = getPreferencesDirectory();
713        if (prefDir.exists()) {
714            if (!prefDir.isDirectory()) {
715                Main.warn(tr("Failed to initialize preferences. Preference directory ''{0}'' is not a directory.",
716                        prefDir.getAbsoluteFile()));
717                JOptionPane.showMessageDialog(
718                        Main.parent,
719                        tr("<html>Failed to initialize preferences.<br>Preference directory ''{0}'' is not a directory.</html>",
720                                prefDir.getAbsoluteFile()),
721                        tr("Error"),
722                        JOptionPane.ERROR_MESSAGE
723                );
724                return;
725            }
726        } else {
727            if (!prefDir.mkdirs()) {
728                Main.warn(tr("Failed to initialize preferences. Failed to create missing preference directory: {0}",
729                        prefDir.getAbsoluteFile()));
730                JOptionPane.showMessageDialog(
731                        Main.parent,
732                        tr("<html>Failed to initialize preferences.<br>Failed to create missing preference directory: {0}</html>",
733                                prefDir.getAbsoluteFile()),
734                        tr("Error"),
735                        JOptionPane.ERROR_MESSAGE
736                );
737                return;
738            }
739        }
740
741        File preferenceFile = getPreferenceFile();
742        try {
743            if (!preferenceFile.exists()) {
744                Main.info(tr("Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
745                resetToDefault();
746                save();
747            } else if (reset) {
748                File backupFile = new File(prefDir, "preferences.xml.bak");
749                Main.platform.rename(preferenceFile, backupFile);
750                Main.warn(tr("Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
751                resetToDefault();
752                save();
753            }
754        } catch (IOException e) {
755            Main.error(e);
756            JOptionPane.showMessageDialog(
757                    Main.parent,
758                    tr("<html>Failed to initialize preferences.<br>Failed to reset preference file to default: {0}</html>",
759                            getPreferenceFile().getAbsoluteFile()),
760                    tr("Error"),
761                    JOptionPane.ERROR_MESSAGE
762            );
763            return;
764        }
765        try {
766            load();
767            initSuccessful = true;
768        } catch (IOException | SAXException | XMLStreamException e) {
769            Main.error(e);
770            File backupFile = new File(prefDir, "preferences.xml.bak");
771            JOptionPane.showMessageDialog(
772                    Main.parent,
773                    tr("<html>Preferences file had errors.<br> Making backup of old one to <br>{0}<br> " +
774                            "and creating a new default preference file.</html>",
775                            backupFile.getAbsoluteFile()),
776                    tr("Error"),
777                    JOptionPane.ERROR_MESSAGE
778            );
779            Main.platform.rename(preferenceFile, backupFile);
780            try {
781                resetToDefault();
782                save();
783            } catch (IOException e1) {
784                Main.error(e1);
785                Main.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
786            }
787        }
788        File def = getDefaultsCacheFile();
789        if (def.exists()) {
790            try {
791                loadDefaults();
792            } catch (IOException | XMLStreamException | SAXException e) {
793                Main.error(e);
794                Main.warn(tr("Failed to load defaults cache file: {0}", def));
795                defaultsMap.clear();
796                if (!def.delete()) {
797                    Main.warn(tr("Failed to delete faulty defaults cache file: {0}", def));
798                }
799            }
800        }
801    }
802
803    /**
804     * Resets the preferences to their initial state. This resets all values and file associations.
805     * The default values and listeners are not removed.
806     * <p>
807     * It is meant to be called before {@link #init(boolean)}
808     * @since 10876
809     */
810    public void resetToInitialState() {
811        resetToDefault();
812        preferencesDir = null;
813        cacheDir = null;
814        userdataDir = null;
815        saveOnPut = true;
816        initSuccessful = false;
817    }
818
819    /**
820     * Reset all values stored in this map to the default values. This clears the preferences.
821     */
822    public final void resetToDefault() {
823        settingsMap.clear();
824    }
825
826    /**
827     * Convenience method for accessing colour preferences.
828     * <p>
829     * To be removed: end of 2016
830     *
831     * @param colName name of the colour
832     * @param def default value
833     * @return a Color object for the configured colour, or the default value if none configured.
834     * @deprecated Use a {@link ColorProperty} instead.
835     */
836    @Deprecated
837    public synchronized Color getColor(String colName, Color def) {
838        return getColor(colName, null, def);
839    }
840
841    /* only for preferences */
842    public synchronized String getColorName(String o) {
843        Matcher m = Pattern.compile("mappaint\\.(.+?)\\.(.+)").matcher(o);
844        if (m.matches()) {
845            return tr("Paint style {0}: {1}", tr(I18n.escape(m.group(1))), tr(I18n.escape(m.group(2))));
846        }
847        m = Pattern.compile("layer (.+)").matcher(o);
848        if (m.matches()) {
849            return tr("Layer: {0}", tr(I18n.escape(m.group(1))));
850        }
851        return tr(I18n.escape(colornames.containsKey(o) ? colornames.get(o) : o));
852    }
853
854    /**
855     * Convenience method for accessing colour preferences.
856     * <p>
857     * To be removed: end of 2016
858     * @param colName name of the colour
859     * @param specName name of the special colour settings
860     * @param def default value
861     * @return a Color object for the configured colour, or the default value if none configured.
862     * @deprecated Use a {@link ColorProperty} instead.
863     * You can replace this by: <code>new ColorProperty(colName, def).getChildColor(specName)</code>
864     */
865    @Deprecated
866    public synchronized Color getColor(String colName, String specName, Color def) {
867        String colKey = ColorProperty.getColorKey(colName);
868        registerColor(colKey, colName);
869        String colStr = specName != null ? get(COLOR_PREFIX+specName) : "";
870        if (colStr.isEmpty()) {
871            colStr = get(colKey, ColorHelper.color2html(def, true));
872        }
873        if (colStr != null && !colStr.isEmpty()) {
874            return ColorHelper.html2color(colStr);
875        } else {
876            return def;
877        }
878    }
879
880    /**
881     * Registers a color name conversion for the global color registry.
882     * @param colKey The key
883     * @param colName The name of the color.
884     * @since 10824
885     */
886    public void registerColor(String colKey, String colName) {
887        if (!colKey.equals(colName)) {
888            colornames.put(colKey, colName);
889        }
890    }
891
892    public synchronized Color getDefaultColor(String colKey) {
893        StringSetting col = Utils.cast(defaultsMap.get(COLOR_PREFIX+colKey), StringSetting.class);
894        String colStr = col == null ? null : col.getValue();
895        return colStr == null || colStr.isEmpty() ? null : ColorHelper.html2color(colStr);
896    }
897
898    public synchronized boolean putColor(String colKey, Color val) {
899        return put(COLOR_PREFIX+colKey, val != null ? ColorHelper.color2html(val, true) : null);
900    }
901
902    public synchronized int getInteger(String key, int def) {
903        String v = get(key, Integer.toString(def));
904        if (v.isEmpty())
905            return def;
906
907        try {
908            return Integer.parseInt(v);
909        } catch (NumberFormatException e) {
910            // fall out
911            Main.trace(e);
912        }
913        return def;
914    }
915
916    public synchronized int getInteger(String key, String specName, int def) {
917        String v = get(key+'.'+specName);
918        if (v.isEmpty())
919            v = get(key, Integer.toString(def));
920        if (v.isEmpty())
921            return def;
922
923        try {
924            return Integer.parseInt(v);
925        } catch (NumberFormatException e) {
926            // fall out
927            Main.trace(e);
928        }
929        return def;
930    }
931
932    public synchronized long getLong(String key, long def) {
933        String v = get(key, Long.toString(def));
934        if (null == v)
935            return def;
936
937        try {
938            return Long.parseLong(v);
939        } catch (NumberFormatException e) {
940            // fall out
941            Main.trace(e);
942        }
943        return def;
944    }
945
946    public synchronized double getDouble(String key, double def) {
947        String v = get(key, Double.toString(def));
948        if (null == v)
949            return def;
950
951        try {
952            return Double.parseDouble(v);
953        } catch (NumberFormatException e) {
954            // fall out
955            Main.trace(e);
956        }
957        return def;
958    }
959
960    /**
961     * Get a list of values for a certain key
962     * @param key the identifier for the setting
963     * @param def the default value.
964     * @return the corresponding value if the property has been set before, {@code def} otherwise
965     */
966    public Collection<String> getCollection(String key, Collection<String> def) {
967        return getSetting(key, ListSetting.create(def), ListSetting.class).getValue();
968    }
969
970    /**
971     * Get a list of values for a certain key
972     * @param key the identifier for the setting
973     * @return the corresponding value if the property has been set before, an empty collection otherwise.
974     */
975    public Collection<String> getCollection(String key) {
976        Collection<String> val = getCollection(key, null);
977        return val == null ? Collections.<String>emptyList() : val;
978    }
979
980    public synchronized void removeFromCollection(String key, String value) {
981        List<String> a = new ArrayList<>(getCollection(key, Collections.<String>emptyList()));
982        a.remove(value);
983        putCollection(key, a);
984    }
985
986    /**
987     * Set a value for a certain setting. The changed setting is saved to the preference file immediately.
988     * Due to caching mechanisms on modern operating systems and hardware, this shouldn't be a performance problem.
989     * @param key the unique identifier for the setting
990     * @param setting the value of the setting. In case it is null, the key-value entry will be removed.
991     * @return {@code true}, if something has changed (i.e. value is different than before)
992     */
993    public boolean putSetting(final String key, Setting<?> setting) {
994        CheckParameterUtil.ensureParameterNotNull(key);
995        if (setting != null && setting.getValue() == null)
996            throw new IllegalArgumentException("setting argument must not have null value");
997        Setting<?> settingOld;
998        Setting<?> settingCopy = null;
999        synchronized (this) {
1000            if (setting == null) {
1001                settingOld = settingsMap.remove(key);
1002                if (settingOld == null)
1003                    return false;
1004            } else {
1005                settingOld = settingsMap.get(key);
1006                if (setting.equals(settingOld))
1007                    return false;
1008                if (settingOld == null && setting.equals(defaultsMap.get(key)))
1009                    return false;
1010                settingCopy = setting.copy();
1011                settingsMap.put(key, settingCopy);
1012            }
1013            if (saveOnPut) {
1014                try {
1015                    save();
1016                } catch (IOException e) {
1017                    Main.warn(e, tr("Failed to persist preferences to ''{0}''", getPreferenceFile().getAbsoluteFile()));
1018                }
1019            }
1020        }
1021        // Call outside of synchronized section in case some listener wait for other thread that wait for preference lock
1022        firePreferenceChanged(key, settingOld, settingCopy);
1023        return true;
1024    }
1025
1026    public synchronized Setting<?> getSetting(String key, Setting<?> def) {
1027        return getSetting(key, def, Setting.class);
1028    }
1029
1030    /**
1031     * Get settings value for a certain key and provide default a value.
1032     * @param <T> the setting type
1033     * @param key the identifier for the setting
1034     * @param def the default value. For each call of getSetting() with a given key, the default value must be the same.
1035     * <code>def</code> must not be null, but the value of <code>def</code> can be null.
1036     * @param klass the setting type (same as T)
1037     * @return the corresponding value if the property has been set before, {@code def} otherwise
1038     */
1039    @SuppressWarnings("unchecked")
1040    public synchronized <T extends Setting<?>> T getSetting(String key, T def, Class<T> klass) {
1041        CheckParameterUtil.ensureParameterNotNull(key);
1042        CheckParameterUtil.ensureParameterNotNull(def);
1043        Setting<?> oldDef = defaultsMap.get(key);
1044        if (oldDef != null && oldDef.isNew() && oldDef.getValue() != null && def.getValue() != null && !def.equals(oldDef)) {
1045            Main.info("Defaults for " + key + " differ: " + def + " != " + defaultsMap.get(key));
1046        }
1047        if (def.getValue() != null || oldDef == null) {
1048            Setting<?> defCopy = def.copy();
1049            defCopy.setTime(System.currentTimeMillis() / 1000);
1050            defCopy.setNew(true);
1051            defaultsMap.put(key, defCopy);
1052        }
1053        Setting<?> prop = settingsMap.get(key);
1054        if (klass.isInstance(prop)) {
1055            return (T) prop;
1056        } else {
1057            return def;
1058        }
1059    }
1060
1061    /**
1062     * Put a collection.
1063     * @param key key
1064     * @param value value
1065     * @return {@code true}, if something has changed (i.e. value is different than before)
1066     */
1067    public boolean putCollection(String key, Collection<String> value) {
1068        return putSetting(key, value == null ? null : ListSetting.create(value));
1069    }
1070
1071    /**
1072     * Saves at most {@code maxsize} items of collection {@code val}.
1073     * @param key key
1074     * @param maxsize max number of items to save
1075     * @param val value
1076     * @return {@code true}, if something has changed (i.e. value is different than before)
1077     */
1078    public boolean putCollectionBounded(String key, int maxsize, Collection<String> val) {
1079        Collection<String> newCollection = new ArrayList<>(Math.min(maxsize, val.size()));
1080        for (String i : val) {
1081            if (newCollection.size() >= maxsize) {
1082                break;
1083            }
1084            newCollection.add(i);
1085        }
1086        return putCollection(key, newCollection);
1087    }
1088
1089    /**
1090     * Used to read a 2-dimensional array of strings from the preference file.
1091     * If not a single entry could be found, <code>def</code> is returned.
1092     * @param key preference key
1093     * @param def default array value
1094     * @return array value
1095     */
1096    @SuppressWarnings({ "unchecked", "rawtypes" })
1097    public synchronized Collection<Collection<String>> getArray(String key, Collection<Collection<String>> def) {
1098        ListListSetting val = getSetting(key, ListListSetting.create(def), ListListSetting.class);
1099        return (Collection) val.getValue();
1100    }
1101
1102    public Collection<Collection<String>> getArray(String key) {
1103        Collection<Collection<String>> res = getArray(key, null);
1104        return res == null ? Collections.<Collection<String>>emptyList() : res;
1105    }
1106
1107    /**
1108     * Put an array.
1109     * @param key key
1110     * @param value value
1111     * @return {@code true}, if something has changed (i.e. value is different than before)
1112     */
1113    public boolean putArray(String key, Collection<Collection<String>> value) {
1114        return putSetting(key, value == null ? null : ListListSetting.create(value));
1115    }
1116
1117    public Collection<Map<String, String>> getListOfStructs(String key, Collection<Map<String, String>> def) {
1118        return getSetting(key, new MapListSetting(def == null ? null : new ArrayList<>(def)), MapListSetting.class).getValue();
1119    }
1120
1121    public boolean putListOfStructs(String key, Collection<Map<String, String>> value) {
1122        return putSetting(key, value == null ? null : new MapListSetting(new ArrayList<>(value)));
1123    }
1124
1125    /**
1126     * Annotation used for converting objects to String Maps and vice versa.
1127     * Indicates that a certain field should be considered in the conversion process. Otherwise it is ignored.
1128     *
1129     * @see #serializeStruct(java.lang.Object, java.lang.Class)
1130     * @see #deserializeStruct(java.util.Map, java.lang.Class)
1131     */
1132    @Retention(RetentionPolicy.RUNTIME) // keep annotation at runtime
1133    public @interface pref { }
1134
1135    /**
1136     * Annotation used for converting objects to String Maps.
1137     * Indicates that a certain field should be written to the map, even if the value is the same as the default value.
1138     *
1139     * @see #serializeStruct(java.lang.Object, java.lang.Class)
1140     */
1141    @Retention(RetentionPolicy.RUNTIME) // keep annotation at runtime
1142    public @interface writeExplicitly { }
1143
1144    /**
1145     * Get a list of hashes which are represented by a struct-like class.
1146     * Possible properties are given by fields of the class klass that have the @pref annotation.
1147     * Default constructor is used to initialize the struct objects, properties then override some of these default values.
1148     * @param <T> klass type
1149     * @param key main preference key
1150     * @param klass The struct class
1151     * @return a list of objects of type T or an empty list if nothing was found
1152     */
1153    public <T> List<T> getListOfStructs(String key, Class<T> klass) {
1154        return Optional.ofNullable(getListOfStructs(key, null, klass)).orElseGet(Collections::emptyList);
1155    }
1156
1157    /**
1158     * same as above, but returns def if nothing was found
1159     * @param <T> klass type
1160     * @param key main preference key
1161     * @param def default value
1162     * @param klass The struct class
1163     * @return a list of objects of type T or {@code def} if nothing was found
1164     */
1165    public <T> List<T> getListOfStructs(String key, Collection<T> def, Class<T> klass) {
1166        Collection<Map<String, String>> prop =
1167            getListOfStructs(key, def == null ? null : serializeListOfStructs(def, klass));
1168        if (prop == null)
1169            return def == null ? null : new ArrayList<>(def);
1170        return prop.stream().map(p -> deserializeStruct(p, klass)).collect(Collectors.toList());
1171    }
1172
1173    /**
1174     * Convenience method that saves a MapListSetting which is provided as a collection of objects.
1175     *
1176     * Each object is converted to a <code>Map&lt;String, String&gt;</code> using the fields with {@link pref} annotation.
1177     * The field name is the key and the value will be converted to a string.
1178     *
1179     * Considers only fields that have the @pref annotation.
1180     * In addition it does not write fields with null values. (Thus they are cleared)
1181     * Default values are given by the field values after default constructor has been called.
1182     * Fields equal to the default value are not written unless the field has the @writeExplicitly annotation.
1183     * @param <T> the class,
1184     * @param key main preference key
1185     * @param val the list that is supposed to be saved
1186     * @param klass The struct class
1187     * @return true if something has changed
1188     */
1189    public <T> boolean putListOfStructs(String key, Collection<T> val, Class<T> klass) {
1190        return putListOfStructs(key, serializeListOfStructs(val, klass));
1191    }
1192
1193    private static <T> Collection<Map<String, String>> serializeListOfStructs(Collection<T> l, Class<T> klass) {
1194        if (l == null)
1195            return null;
1196        Collection<Map<String, String>> vals = new ArrayList<>();
1197        for (T struct : l) {
1198            if (struct != null) {
1199                vals.add(serializeStruct(struct, klass));
1200            }
1201        }
1202        return vals;
1203    }
1204
1205    @SuppressWarnings("rawtypes")
1206    private static String mapToJson(Map map) {
1207        StringWriter stringWriter = new StringWriter();
1208        try (JsonWriter writer = Json.createWriter(stringWriter)) {
1209            JsonObjectBuilder object = Json.createObjectBuilder();
1210            for (Object o: map.entrySet()) {
1211                Entry e = (Entry) o;
1212                Object evalue = e.getValue();
1213                object.add(e.getKey().toString(), evalue.toString());
1214            }
1215            writer.writeObject(object.build());
1216        }
1217        return stringWriter.toString();
1218    }
1219
1220    @SuppressWarnings({ "rawtypes", "unchecked" })
1221    private static Map mapFromJson(String s) {
1222        Map ret = null;
1223        try (JsonReader reader = Json.createReader(new StringReader(s))) {
1224            JsonObject object = reader.readObject();
1225            ret = new HashMap(object.size());
1226            for (Entry<String, JsonValue> e: object.entrySet()) {
1227                JsonValue value = e.getValue();
1228                if (value instanceof JsonString) {
1229                    // in some cases, when JsonValue.toString() is called, then additional quotation marks are left in value
1230                    ret.put(e.getKey(), ((JsonString) value).getString());
1231                } else {
1232                    ret.put(e.getKey(), e.getValue().toString());
1233                }
1234            }
1235        }
1236        return ret;
1237    }
1238
1239    @SuppressWarnings("rawtypes")
1240    private static String multiMapToJson(MultiMap map) {
1241        StringWriter stringWriter = new StringWriter();
1242        try (JsonWriter writer = Json.createWriter(stringWriter)) {
1243            JsonObjectBuilder object = Json.createObjectBuilder();
1244            for (Object o: map.entrySet()) {
1245                Entry e = (Entry) o;
1246                Set evalue = (Set) e.getValue();
1247                JsonArrayBuilder a = Json.createArrayBuilder();
1248                for (Object evo: evalue) {
1249                    a.add(evo.toString());
1250                }
1251                object.add(e.getKey().toString(), a.build());
1252            }
1253            writer.writeObject(object.build());
1254        }
1255        return stringWriter.toString();
1256    }
1257
1258    @SuppressWarnings({ "rawtypes", "unchecked" })
1259    private static MultiMap multiMapFromJson(String s) {
1260        MultiMap ret = null;
1261        try (JsonReader reader = Json.createReader(new StringReader(s))) {
1262            JsonObject object = reader.readObject();
1263            ret = new MultiMap(object.size());
1264            for (Entry<String, JsonValue> e: object.entrySet()) {
1265                JsonValue value = e.getValue();
1266                if (value instanceof JsonArray) {
1267                    for (JsonString js: ((JsonArray) value).getValuesAs(JsonString.class)) {
1268                        ret.put(e.getKey(), js.getString());
1269                    }
1270                } else if (value instanceof JsonString) {
1271                    // in some cases, when JsonValue.toString() is called, then additional quotation marks are left in value
1272                    ret.put(e.getKey(), ((JsonString) value).getString());
1273                } else {
1274                    ret.put(e.getKey(), e.getValue().toString());
1275                }
1276            }
1277        }
1278        return ret;
1279    }
1280
1281    /**
1282     * Convert an object to a String Map, by using field names and values as map key and value.
1283     *
1284     * The field value is converted to a String.
1285     *
1286     * Only fields with annotation {@link pref} are taken into account.
1287     *
1288     * Fields will not be written to the map if the value is null or unchanged
1289     * (compared to an object created with the no-arg-constructor).
1290     * The {@link writeExplicitly} annotation overrides this behavior, i.e. the default value will also be written.
1291     *
1292     * @param <T> the class of the object <code>struct</code>
1293     * @param struct the object to be converted
1294     * @param klass the class T
1295     * @return the resulting map (same data content as <code>struct</code>)
1296     */
1297    public static <T> Map<String, String> serializeStruct(T struct, Class<T> klass) {
1298        T structPrototype;
1299        try {
1300            structPrototype = klass.getConstructor().newInstance();
1301        } catch (ReflectiveOperationException ex) {
1302            throw new IllegalArgumentException(ex);
1303        }
1304
1305        Map<String, String> hash = new LinkedHashMap<>();
1306        for (Field f : klass.getDeclaredFields()) {
1307            if (f.getAnnotation(pref.class) == null) {
1308                continue;
1309            }
1310            Utils.setObjectsAccessible(f);
1311            try {
1312                Object fieldValue = f.get(struct);
1313                Object defaultFieldValue = f.get(structPrototype);
1314                if (fieldValue != null && (f.getAnnotation(writeExplicitly.class) != null || !Objects.equals(fieldValue, defaultFieldValue))) {
1315                    String key = f.getName().replace('_', '-');
1316                    if (fieldValue instanceof Map) {
1317                        hash.put(key, mapToJson((Map<?, ?>) fieldValue));
1318                    } else if (fieldValue instanceof MultiMap) {
1319                        hash.put(key, multiMapToJson((MultiMap<?, ?>) fieldValue));
1320                    } else {
1321                        hash.put(key, fieldValue.toString());
1322                    }
1323                }
1324            } catch (IllegalAccessException ex) {
1325                throw new JosmRuntimeException(ex);
1326            }
1327        }
1328        return hash;
1329    }
1330
1331    /**
1332     * Converts a String-Map to an object of a certain class, by comparing map keys to field names of the class and assigning
1333     * map values to the corresponding fields.
1334     *
1335     * The map value (a String) is converted to the field type. Supported types are: boolean, Boolean, int, Integer, double,
1336     * Double, String, Map&lt;String, String&gt; and Map&lt;String, List&lt;String&gt;&gt;.
1337     *
1338     * Only fields with annotation {@link pref} are taken into account.
1339     * @param <T> the class
1340     * @param hash the string map with initial values
1341     * @param klass the class T
1342     * @return an object of class T, initialized as described above
1343     */
1344    public static <T> T deserializeStruct(Map<String, String> hash, Class<T> klass) {
1345        T struct = null;
1346        try {
1347            struct = klass.getConstructor().newInstance();
1348        } catch (ReflectiveOperationException ex) {
1349            throw new IllegalArgumentException(ex);
1350        }
1351        for (Entry<String, String> key_value : hash.entrySet()) {
1352            Object value;
1353            Field f;
1354            try {
1355                f = klass.getDeclaredField(key_value.getKey().replace('-', '_'));
1356            } catch (NoSuchFieldException ex) {
1357                Main.trace(ex);
1358                continue;
1359            }
1360            if (f.getAnnotation(pref.class) == null) {
1361                continue;
1362            }
1363            Utils.setObjectsAccessible(f);
1364            if (f.getType() == Boolean.class || f.getType() == boolean.class) {
1365                value = Boolean.valueOf(key_value.getValue());
1366            } else if (f.getType() == Integer.class || f.getType() == int.class) {
1367                try {
1368                    value = Integer.valueOf(key_value.getValue());
1369                } catch (NumberFormatException nfe) {
1370                    continue;
1371                }
1372            } else if (f.getType() == Double.class || f.getType() == double.class) {
1373                try {
1374                    value = Double.valueOf(key_value.getValue());
1375                } catch (NumberFormatException nfe) {
1376                    continue;
1377                }
1378            } else if (f.getType() == String.class) {
1379                value = key_value.getValue();
1380            } else if (f.getType().isAssignableFrom(Map.class)) {
1381                value = mapFromJson(key_value.getValue());
1382            } else if (f.getType().isAssignableFrom(MultiMap.class)) {
1383                value = multiMapFromJson(key_value.getValue());
1384            } else
1385                throw new JosmRuntimeException("unsupported preference primitive type");
1386
1387            try {
1388                f.set(struct, value);
1389            } catch (IllegalArgumentException ex) {
1390                throw new AssertionError(ex);
1391            } catch (IllegalAccessException ex) {
1392                throw new JosmRuntimeException(ex);
1393            }
1394        }
1395        return struct;
1396    }
1397
1398    public Map<String, Setting<?>> getAllSettings() {
1399        return new TreeMap<>(settingsMap);
1400    }
1401
1402    public Map<String, Setting<?>> getAllDefaults() {
1403        return new TreeMap<>(defaultsMap);
1404    }
1405
1406    /**
1407     * Updates system properties with the current values in the preferences.
1408     */
1409    public void updateSystemProperties() {
1410        if ("true".equals(get("prefer.ipv6", "auto")) && !"true".equals(Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true"))) {
1411            // never set this to false, only true!
1412            Main.info(tr("Try enabling IPv6 network, prefering IPv6 over IPv4 (only works on early startup)."));
1413        }
1414        Utils.updateSystemProperty("http.agent", Version.getInstance().getAgentString());
1415        Utils.updateSystemProperty("user.language", get("language"));
1416        // Workaround to fix a Java bug. This ugly hack comes from Sun bug database: https://bugs.openjdk.java.net/browse/JDK-6292739
1417        // Force AWT toolkit to update its internal preferences (fix #6345).
1418        // Does not work anymore with Java 9, to remove with Java 9 migration
1419        if (Utils.getJavaVersion() < 9 && !GraphicsEnvironment.isHeadless()) {
1420            try {
1421                Field field = Toolkit.class.getDeclaredField("resources");
1422                Utils.setObjectsAccessible(field);
1423                field.set(null, ResourceBundle.getBundle("sun.awt.resources.awt"));
1424            } catch (ReflectiveOperationException | RuntimeException e) { // NOPMD
1425                // Catch RuntimeException in order to catch InaccessibleObjectException, new in Java 9
1426                Main.warn(e);
1427            }
1428        }
1429        // Possibility to disable SNI (not by default) in case of misconfigured https servers
1430        // See #9875 + http://stackoverflow.com/a/14884941/2257172
1431        // then https://josm.openstreetmap.de/ticket/12152#comment:5 for details
1432        if (getBoolean("jdk.tls.disableSNIExtension", false)) {
1433            Utils.updateSystemProperty("jsse.enableSNIExtension", "false");
1434        }
1435    }
1436
1437    /**
1438     * Replies the collection of plugin site URLs from where plugin lists can be downloaded.
1439     * @return the collection of plugin site URLs
1440     * @see #getOnlinePluginSites
1441     */
1442    public Collection<String> getPluginSites() {
1443        return getCollection("pluginmanager.sites", Collections.singleton(Main.getJOSMWebsite()+"/pluginicons%<?plugins=>"));
1444    }
1445
1446    /**
1447     * Returns the list of plugin sites available according to offline mode settings.
1448     * @return the list of available plugin sites
1449     * @since 8471
1450     */
1451    public Collection<String> getOnlinePluginSites() {
1452        Collection<String> pluginSites = new ArrayList<>(getPluginSites());
1453        for (Iterator<String> it = pluginSites.iterator(); it.hasNext();) {
1454            try {
1455                OnlineResource.JOSM_WEBSITE.checkOfflineAccess(it.next(), Main.getJOSMWebsite());
1456            } catch (OfflineAccessException ex) {
1457                Main.warn(ex, false);
1458                it.remove();
1459            }
1460        }
1461        return pluginSites;
1462    }
1463
1464    /**
1465     * Sets the collection of plugin site URLs.
1466     *
1467     * @param sites the site URLs
1468     */
1469    public void setPluginSites(Collection<String> sites) {
1470        putCollection("pluginmanager.sites", sites);
1471    }
1472
1473    /**
1474     * Returns XML describing these preferences.
1475     * @param nopass if password must be excluded
1476     * @return XML
1477     */
1478    public String toXML(boolean nopass) {
1479        return toXML(settingsMap.entrySet(), nopass, false);
1480    }
1481
1482    /**
1483     * Returns XML describing the given preferences.
1484     * @param settings preferences settings
1485     * @param nopass if password must be excluded
1486     * @param defaults true, if default values are converted to XML, false for
1487     * regular preferences
1488     * @return XML
1489     */
1490    public String toXML(Collection<Entry<String, Setting<?>>> settings, boolean nopass, boolean defaults) {
1491        try (
1492            StringWriter sw = new StringWriter();
1493            PreferencesWriter prefWriter = new PreferencesWriter(new PrintWriter(sw), nopass, defaults)
1494        ) {
1495            prefWriter.write(settings);
1496            sw.flush();
1497            return sw.toString();
1498        } catch (IOException e) {
1499            Main.error(e);
1500            return null;
1501        }
1502    }
1503
1504    /**
1505     * Removes obsolete preference settings. If you throw out a once-used preference
1506     * setting, add it to the list here with an expiry date (written as comment). If you
1507     * see something with an expiry date in the past, remove it from the list.
1508     * @param loadedVersion JOSM version when the preferences file was written
1509     */
1510    private void removeObsolete(int loadedVersion) {
1511        // drop in March 2017
1512        removeUrlFromEntries(loadedVersion, 10063,
1513                "validator.org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.entries",
1514                "resource://data/validator/power.mapcss");
1515        // drop in March 2017
1516        if (loadedVersion < 11058) {
1517            migrateOldColorKeys();
1518        }
1519        // drop in September 2017
1520        if (loadedVersion < 11424) {
1521            addNewerDefaultEntry(
1522                    "validator.org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.entries",
1523                    "resource://data/validator/territories.mapcss");
1524        }
1525
1526        for (String key : OBSOLETE_PREF_KEYS) {
1527            if (settingsMap.containsKey(key)) {
1528                settingsMap.remove(key);
1529                Main.info(tr("Preference setting {0} has been removed since it is no longer used.", key));
1530            }
1531        }
1532    }
1533
1534    private void migrateOldColorKeys() {
1535        settingsMap.keySet().stream()
1536                .filter(key -> key.startsWith(COLOR_PREFIX))
1537                .flatMap(this::searchOldColorKey)
1538                .collect(Collectors.toList()) // to avoid ConcurrentModificationException
1539                .forEach(entry -> {
1540                    final String oldKey = entry.getKey();
1541                    final String newKey = entry.getValue();
1542                    Main.info("Migrating old color key {0} => {1}", oldKey, newKey);
1543                    put(newKey, get(oldKey));
1544                    put(oldKey, null);
1545                });
1546    }
1547
1548    private Stream<AbstractMap.SimpleImmutableEntry<String, String>> searchOldColorKey(String key) {
1549        final String newKey = ColorProperty.getColorKey(key.substring(COLOR_PREFIX.length()));
1550        return key.equals(newKey) || settingsMap.containsKey(newKey)
1551                ? Stream.empty()
1552                : Stream.of(new AbstractMap.SimpleImmutableEntry<>(key, newKey));
1553    }
1554
1555    private void removeUrlFromEntries(int loadedVersion, int versionMax, String key, String urlPart) {
1556        if (loadedVersion < versionMax) {
1557            Setting<?> setting = settingsMap.get(key);
1558            if (setting instanceof MapListSetting) {
1559                List<Map<String, String>> l = new LinkedList<>();
1560                boolean modified = false;
1561                for (Map<String, String> map: ((MapListSetting) setting).getValue()) {
1562                    String url = map.get("url");
1563                    if (url != null && url.contains(urlPart)) {
1564                        modified = true;
1565                    } else {
1566                        l.add(map);
1567                    }
1568                }
1569                if (modified) {
1570                    putListOfStructs(key, l);
1571                }
1572            }
1573        }
1574    }
1575
1576    private void addNewerDefaultEntry(String key, final String url) {
1577        Setting<?> setting = settingsMap.get(key);
1578        if (setting instanceof MapListSetting) {
1579            List<Map<String, String>> l = new ArrayList<>(((MapListSetting) setting).getValue());
1580            if (l.stream().noneMatch(x -> x.containsValue(url))) {
1581                RulePrefHelper helper = ValidatorTagCheckerRulesPreference.RulePrefHelper.INSTANCE;
1582                Optional<ExtendedSourceEntry> val = helper.getDefault().stream().filter(x -> url.equals(x.url)).findFirst();
1583                if (val.isPresent()) {
1584                    l.add(helper.serialize(val.get()));
1585                }
1586                putListOfStructs(key, l);
1587            }
1588        }
1589    }
1590
1591    /**
1592     * Enables or not the preferences file auto-save mechanism (save each time a setting is changed).
1593     * This behaviour is enabled by default.
1594     * @param enable if {@code true}, makes JOSM save preferences file each time a setting is changed
1595     * @since 7085
1596     */
1597    public final void enableSaveOnPut(boolean enable) {
1598        synchronized (this) {
1599            saveOnPut = enable;
1600        }
1601    }
1602}
Note: See TracBrowser for help on using the repository browser.