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

Last change on this file since 14153 was 14153, checked in by Don-vip, 6 years ago

see #15229 - deprecate Main.parent and Main itself
  • Property svn:eol-style set to native
File size: 30.1 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;
6import static org.openstreetmap.josm.tools.Utils.getSystemEnv;
7import static org.openstreetmap.josm.tools.Utils.getSystemProperty;
8
9import java.awt.GraphicsEnvironment;
10import java.io.File;
11import java.io.IOException;
12import java.io.PrintWriter;
13import java.io.Reader;
14import java.io.StringWriter;
15import java.nio.charset.StandardCharsets;
16import java.nio.file.InvalidPathException;
17import java.util.ArrayList;
18import java.util.Collection;
19import java.util.Collections;
20import java.util.HashMap;
21import java.util.HashSet;
22import java.util.Iterator;
23import java.util.Map;
24import java.util.Map.Entry;
25import java.util.Optional;
26import java.util.Set;
27import java.util.SortedMap;
28import java.util.TreeMap;
29import java.util.concurrent.TimeUnit;
30import java.util.function.Predicate;
31import java.util.stream.Stream;
32
33import javax.swing.JOptionPane;
34import javax.xml.stream.XMLStreamException;
35
36import org.openstreetmap.josm.data.preferences.ColorInfo;
37import org.openstreetmap.josm.data.preferences.JosmBaseDirectories;
38import org.openstreetmap.josm.data.preferences.NamedColorProperty;
39import org.openstreetmap.josm.data.preferences.PreferencesReader;
40import org.openstreetmap.josm.data.preferences.PreferencesWriter;
41import org.openstreetmap.josm.gui.MainApplication;
42import org.openstreetmap.josm.io.OfflineAccessException;
43import org.openstreetmap.josm.io.OnlineResource;
44import org.openstreetmap.josm.spi.preferences.AbstractPreferences;
45import org.openstreetmap.josm.spi.preferences.Config;
46import org.openstreetmap.josm.spi.preferences.IBaseDirectories;
47import org.openstreetmap.josm.spi.preferences.ListSetting;
48import org.openstreetmap.josm.spi.preferences.Setting;
49import org.openstreetmap.josm.tools.CheckParameterUtil;
50import org.openstreetmap.josm.tools.ListenerList;
51import org.openstreetmap.josm.tools.Logging;
52import org.openstreetmap.josm.tools.PlatformManager;
53import org.openstreetmap.josm.tools.Utils;
54import org.xml.sax.SAXException;
55
56/**
57 * This class holds all preferences for JOSM.
58 *
59 * Other classes can register their beloved properties here. All properties will be
60 * saved upon set-access.
61 *
62 * Each property is a key=setting pair, where key is a String and setting can be one of
63 * 4 types:
64 * string, list, list of lists and list of maps.
65 * In addition, each key has a unique default value that is set when the value is first
66 * accessed using one of the get...() methods. You can use the same preference
67 * key in different parts of the code, but the default value must be the same
68 * everywhere. A default value of null means, the setting has been requested, but
69 * no default value was set. This is used in advanced preferences to present a list
70 * off all possible settings.
71 *
72 * At the moment, you cannot put the empty string for string properties.
73 * put(key, "") means, the property is removed.
74 *
75 * @author imi
76 * @since 74
77 */
78public class Preferences extends AbstractPreferences {
79
80 private static final String[] OBSOLETE_PREF_KEYS = {
81 };
82
83 private static final long MAX_AGE_DEFAULT_PREFERENCES = TimeUnit.DAYS.toSeconds(50);
84
85 private final IBaseDirectories dirs;
86
87 /**
88 * Determines if preferences file is saved each time a property is changed.
89 */
90 private boolean saveOnPut = true;
91
92 /**
93 * Maps the setting name to the current value of the setting.
94 * The map must not contain null as key or value. The mapped setting objects
95 * must not have a null value.
96 */
97 protected final SortedMap<String, Setting<?>> settingsMap = new TreeMap<>();
98
99 /**
100 * Maps the setting name to the default value of the setting.
101 * The map must not contain null as key or value. The value of the mapped
102 * setting objects can be null.
103 */
104 protected final SortedMap<String, Setting<?>> defaultsMap = new TreeMap<>();
105
106 private final Predicate<Entry<String, Setting<?>>> NO_DEFAULT_SETTINGS_ENTRY =
107 e -> !e.getValue().equals(defaultsMap.get(e.getKey()));
108
109 /**
110 * Indicates whether {@link #init(boolean)} completed successfully.
111 * Used to decide whether to write backup preference file in {@link #save()}
112 */
113 protected boolean initSuccessful;
114
115 private final ListenerList<org.openstreetmap.josm.spi.preferences.PreferenceChangedListener> listeners = ListenerList.create();
116
117 private final HashMap<String, ListenerList<org.openstreetmap.josm.spi.preferences.PreferenceChangedListener>> keyListeners = new HashMap<>();
118
119 private static final Preferences defaultInstance = new Preferences(JosmBaseDirectories.getInstance());
120
121 /**
122 * Constructs a new {@code Preferences}.
123 */
124 public Preferences() {
125 this.dirs = Config.getDirs();
126 }
127
128 /**
129 * Constructs a new {@code Preferences}.
130 *
131 * @param dirs the directories to use for saving the preferences
132 */
133 public Preferences(IBaseDirectories dirs) {
134 this.dirs = dirs;
135 }
136
137 /**
138 * Constructs a new {@code Preferences} from an existing instance.
139 * @param pref existing preferences to copy
140 * @since 12634
141 */
142 public Preferences(Preferences pref) {
143 this(pref.dirs);
144 settingsMap.putAll(pref.settingsMap);
145 defaultsMap.putAll(pref.defaultsMap);
146 }
147
148 /**
149 * Returns the main (default) preferences instance.
150 * @return the main (default) preferences instance
151 * @since 14149
152 */
153 public static Preferences main() {
154 return defaultInstance;
155 }
156
157 /**
158 * Adds a new preferences listener.
159 * @param listener The listener to add
160 * @since 12881
161 */
162 @Override
163 public void addPreferenceChangeListener(org.openstreetmap.josm.spi.preferences.PreferenceChangedListener listener) {
164 if (listener != null) {
165 listeners.addListener(listener);
166 }
167 }
168
169 /**
170 * Removes a preferences listener.
171 * @param listener The listener to remove
172 * @since 12881
173 */
174 @Override
175 public void removePreferenceChangeListener(org.openstreetmap.josm.spi.preferences.PreferenceChangedListener listener) {
176 listeners.removeListener(listener);
177 }
178
179 /**
180 * Adds a listener that only listens to changes in one preference
181 * @param key The preference key to listen to
182 * @param listener The listener to add.
183 * @since 12881
184 */
185 @Override
186 public void addKeyPreferenceChangeListener(String key, org.openstreetmap.josm.spi.preferences.PreferenceChangedListener listener) {
187 listenersForKey(key).addListener(listener);
188 }
189
190 /**
191 * Adds a weak listener that only listens to changes in one preference
192 * @param key The preference key to listen to
193 * @param listener The listener to add.
194 * @since 10824
195 */
196 public void addWeakKeyPreferenceChangeListener(String key, org.openstreetmap.josm.spi.preferences.PreferenceChangedListener listener) {
197 listenersForKey(key).addWeakListener(listener);
198 }
199
200 private ListenerList<org.openstreetmap.josm.spi.preferences.PreferenceChangedListener> listenersForKey(String key) {
201 return keyListeners.computeIfAbsent(key, k -> ListenerList.create());
202 }
203
204 /**
205 * Removes a listener that only listens to changes in one preference
206 * @param key The preference key to listen to
207 * @param listener The listener to add.
208 * @since 12881
209 */
210 @Override
211 public void removeKeyPreferenceChangeListener(String key, org.openstreetmap.josm.spi.preferences.PreferenceChangedListener listener) {
212 Optional.ofNullable(keyListeners.get(key)).orElseThrow(
213 () -> new IllegalArgumentException("There are no listeners registered for " + key))
214 .removeListener(listener);
215 }
216
217 protected void firePreferenceChanged(String key, Setting<?> oldValue, Setting<?> newValue) {
218 final org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent evt =
219 new org.openstreetmap.josm.spi.preferences.DefaultPreferenceChangeEvent(key, oldValue, newValue);
220 listeners.fireEvent(listener -> listener.preferenceChanged(evt));
221
222 ListenerList<org.openstreetmap.josm.spi.preferences.PreferenceChangedListener> forKey = keyListeners.get(key);
223 if (forKey != null) {
224 forKey.fireEvent(listener -> listener.preferenceChanged(evt));
225 }
226 }
227
228 /**
229 * Get the base name of the JOSM directories for preferences, cache and user data.
230 * Default value is "JOSM", unless overridden by system property "josm.dir.name".
231 * @return the base name of the JOSM directories for preferences, cache and user data
232 */
233 public static String getJOSMDirectoryBaseName() {
234 String name = getSystemProperty("josm.dir.name");
235 if (name != null)
236 return name;
237 else
238 return "JOSM";
239 }
240
241 /**
242 * Get the base directories associated with this preference instance.
243 * @return the base directories
244 */
245 public IBaseDirectories getDirs() {
246 return dirs;
247 }
248
249 /**
250 * Returns the user preferences file (preferences.xml).
251 * @return The user preferences file (preferences.xml)
252 */
253 public File getPreferenceFile() {
254 return new File(dirs.getPreferencesDirectory(false), "preferences.xml");
255 }
256
257 /**
258 * Returns the cache file for default preferences.
259 * @return the cache file for default preferences
260 */
261 public File getDefaultsCacheFile() {
262 return new File(dirs.getCacheDirectory(true), "default_preferences.xml");
263 }
264
265 /**
266 * Returns the user plugin directory.
267 * @return The user plugin directory
268 */
269 public File getPluginsDirectory() {
270 return new File(dirs.getUserDataDirectory(false), "plugins");
271 }
272
273 private static void addPossibleResourceDir(Set<String> locations, String s) {
274 if (s != null) {
275 if (!s.endsWith(File.separator)) {
276 s += File.separator;
277 }
278 locations.add(s);
279 }
280 }
281
282 /**
283 * Returns a set of all existing directories where resources could be stored.
284 * @return A set of all existing directories where resources could be stored.
285 */
286 public static Collection<String> getAllPossiblePreferenceDirs() {
287 Set<String> locations = new HashSet<>();
288 addPossibleResourceDir(locations, defaultInstance.dirs.getPreferencesDirectory(false).getPath());
289 addPossibleResourceDir(locations, defaultInstance.dirs.getUserDataDirectory(false).getPath());
290 addPossibleResourceDir(locations, getSystemEnv("JOSM_RESOURCES"));
291 addPossibleResourceDir(locations, getSystemProperty("josm.resources"));
292 locations.addAll(PlatformManager.getPlatform().getPossiblePreferenceDirs());
293 return locations;
294 }
295
296 /**
297 * Get all named colors, including customized and the default ones.
298 * @return a map of all named colors (maps preference key to {@link ColorInfo})
299 */
300 public synchronized Map<String, ColorInfo> getAllNamedColors() {
301 final Map<String, ColorInfo> all = new TreeMap<>();
302 for (final Entry<String, Setting<?>> e : settingsMap.entrySet()) {
303 if (!e.getKey().startsWith(NamedColorProperty.NAMED_COLOR_PREFIX))
304 continue;
305 Utils.instanceOfAndCast(e.getValue(), ListSetting.class)
306 .map(ListSetting::getValue)
307 .map(lst -> ColorInfo.fromPref(lst, false))
308 .ifPresent(info -> all.put(e.getKey(), info));
309 }
310 for (final Entry<String, Setting<?>> e : defaultsMap.entrySet()) {
311 if (!e.getKey().startsWith(NamedColorProperty.NAMED_COLOR_PREFIX))
312 continue;
313 Utils.instanceOfAndCast(e.getValue(), ListSetting.class)
314 .map(ListSetting::getValue)
315 .map(lst -> ColorInfo.fromPref(lst, true))
316 .ifPresent(infoDef -> {
317 ColorInfo info = all.get(e.getKey());
318 if (info == null) {
319 all.put(e.getKey(), infoDef);
320 } else {
321 info.setDefaultValue(infoDef.getDefaultValue());
322 }
323 });
324 }
325 return all;
326 }
327
328 /**
329 * Called after every put. In case of a problem, do nothing but output the error in log.
330 * @throws IOException if any I/O error occurs
331 */
332 public synchronized void save() throws IOException {
333 save(getPreferenceFile(), settingsMap.entrySet().stream().filter(NO_DEFAULT_SETTINGS_ENTRY), false);
334 }
335
336 /**
337 * Stores the defaults to the defaults file
338 * @throws IOException If the file could not be saved
339 */
340 public synchronized void saveDefaults() throws IOException {
341 save(getDefaultsCacheFile(), defaultsMap.entrySet().stream(), true);
342 }
343
344 protected void save(File prefFile, Stream<Entry<String, Setting<?>>> settings, boolean defaults) throws IOException {
345 if (!defaults) {
346 /* currently unused, but may help to fix configuration issues in future */
347 putInt("josm.version", Version.getInstance().getVersion());
348 }
349
350 File backupFile = new File(prefFile + "_backup");
351
352 // Backup old preferences if there are old preferences
353 if (initSuccessful && prefFile.exists() && prefFile.length() > 0) {
354 Utils.copyFile(prefFile, backupFile);
355 }
356
357 try (PreferencesWriter writer = new PreferencesWriter(
358 new PrintWriter(new File(prefFile + "_tmp"), StandardCharsets.UTF_8.name()), false, defaults)) {
359 writer.write(settings);
360 } catch (SecurityException e) {
361 throw new IOException(e);
362 }
363
364 File tmpFile = new File(prefFile + "_tmp");
365 Utils.copyFile(tmpFile, prefFile);
366 Utils.deleteFile(tmpFile, marktr("Unable to delete temporary file {0}"));
367
368 setCorrectPermissions(prefFile);
369 setCorrectPermissions(backupFile);
370 }
371
372 private static void setCorrectPermissions(File file) {
373 if (!file.setReadable(false, false) && Logging.isTraceEnabled()) {
374 Logging.trace(tr("Unable to set file non-readable {0}", file.getAbsolutePath()));
375 }
376 if (!file.setWritable(false, false) && Logging.isTraceEnabled()) {
377 Logging.trace(tr("Unable to set file non-writable {0}", file.getAbsolutePath()));
378 }
379 if (!file.setExecutable(false, false) && Logging.isTraceEnabled()) {
380 Logging.trace(tr("Unable to set file non-executable {0}", file.getAbsolutePath()));
381 }
382 if (!file.setReadable(true, true) && Logging.isTraceEnabled()) {
383 Logging.trace(tr("Unable to set file readable {0}", file.getAbsolutePath()));
384 }
385 if (!file.setWritable(true, true) && Logging.isTraceEnabled()) {
386 Logging.trace(tr("Unable to set file writable {0}", file.getAbsolutePath()));
387 }
388 }
389
390 /**
391 * Loads preferences from settings file.
392 * @throws IOException if any I/O error occurs while reading the file
393 * @throws SAXException if the settings file does not contain valid XML
394 * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
395 */
396 protected void load() throws IOException, SAXException, XMLStreamException {
397 File pref = getPreferenceFile();
398 PreferencesReader.validateXML(pref);
399 PreferencesReader reader = new PreferencesReader(pref, false);
400 reader.parse();
401 settingsMap.clear();
402 settingsMap.putAll(reader.getSettings());
403 removeObsolete(reader.getVersion());
404 }
405
406 /**
407 * Loads default preferences from default settings cache file.
408 *
409 * Discards entries older than {@link #MAX_AGE_DEFAULT_PREFERENCES}.
410 *
411 * @throws IOException if any I/O error occurs while reading the file
412 * @throws SAXException if the settings file does not contain valid XML
413 * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
414 */
415 protected void loadDefaults() throws IOException, XMLStreamException, SAXException {
416 File def = getDefaultsCacheFile();
417 PreferencesReader.validateXML(def);
418 PreferencesReader reader = new PreferencesReader(def, true);
419 reader.parse();
420 defaultsMap.clear();
421 long minTime = System.currentTimeMillis() / 1000 - MAX_AGE_DEFAULT_PREFERENCES;
422 for (Entry<String, Setting<?>> e : reader.getSettings().entrySet()) {
423 if (e.getValue().getTime() >= minTime) {
424 defaultsMap.put(e.getKey(), e.getValue());
425 }
426 }
427 }
428
429 /**
430 * Loads preferences from XML reader.
431 * @param in XML reader
432 * @throws XMLStreamException if any XML stream error occurs
433 * @throws IOException if any I/O error occurs
434 */
435 public void fromXML(Reader in) throws XMLStreamException, IOException {
436 PreferencesReader reader = new PreferencesReader(in, false);
437 reader.parse();
438 settingsMap.clear();
439 settingsMap.putAll(reader.getSettings());
440 }
441
442 /**
443 * Initializes preferences.
444 * @param reset if {@code true}, current settings file is replaced by the default one
445 */
446 public void init(boolean reset) {
447 initSuccessful = false;
448 // get the preferences.
449 File prefDir = dirs.getPreferencesDirectory(false);
450 if (prefDir.exists()) {
451 if (!prefDir.isDirectory()) {
452 Logging.warn(tr("Failed to initialize preferences. Preference directory ''{0}'' is not a directory.",
453 prefDir.getAbsoluteFile()));
454 if (!GraphicsEnvironment.isHeadless()) {
455 JOptionPane.showMessageDialog(
456 MainApplication.getMainFrame(),
457 tr("<html>Failed to initialize preferences.<br>Preference directory ''{0}'' is not a directory.</html>",
458 prefDir.getAbsoluteFile()),
459 tr("Error"),
460 JOptionPane.ERROR_MESSAGE
461 );
462 }
463 return;
464 }
465 } else {
466 if (!prefDir.mkdirs()) {
467 Logging.warn(tr("Failed to initialize preferences. Failed to create missing preference directory: {0}",
468 prefDir.getAbsoluteFile()));
469 if (!GraphicsEnvironment.isHeadless()) {
470 JOptionPane.showMessageDialog(
471 MainApplication.getMainFrame(),
472 tr("<html>Failed to initialize preferences.<br>Failed to create missing preference directory: {0}</html>",
473 prefDir.getAbsoluteFile()),
474 tr("Error"),
475 JOptionPane.ERROR_MESSAGE
476 );
477 }
478 return;
479 }
480 }
481
482 File preferenceFile = getPreferenceFile();
483 try {
484 if (!preferenceFile.exists()) {
485 Logging.info(tr("Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
486 resetToDefault();
487 save();
488 } else if (reset) {
489 File backupFile = new File(prefDir, "preferences.xml.bak");
490 PlatformManager.getPlatform().rename(preferenceFile, backupFile);
491 Logging.warn(tr("Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
492 resetToDefault();
493 save();
494 }
495 } catch (IOException | InvalidPathException e) {
496 Logging.error(e);
497 if (!GraphicsEnvironment.isHeadless()) {
498 JOptionPane.showMessageDialog(
499 MainApplication.getMainFrame(),
500 tr("<html>Failed to initialize preferences.<br>Failed to reset preference file to default: {0}</html>",
501 getPreferenceFile().getAbsoluteFile()),
502 tr("Error"),
503 JOptionPane.ERROR_MESSAGE
504 );
505 }
506 return;
507 }
508 try {
509 load();
510 initSuccessful = true;
511 } catch (IOException | SAXException | XMLStreamException e) {
512 Logging.error(e);
513 File backupFile = new File(prefDir, "preferences.xml.bak");
514 if (!GraphicsEnvironment.isHeadless()) {
515 JOptionPane.showMessageDialog(
516 MainApplication.getMainFrame(),
517 tr("<html>Preferences file had errors.<br> Making backup of old one to <br>{0}<br> " +
518 "and creating a new default preference file.</html>",
519 backupFile.getAbsoluteFile()),
520 tr("Error"),
521 JOptionPane.ERROR_MESSAGE
522 );
523 }
524 PlatformManager.getPlatform().rename(preferenceFile, backupFile);
525 try {
526 resetToDefault();
527 save();
528 } catch (IOException e1) {
529 Logging.error(e1);
530 Logging.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
531 }
532 }
533 File def = getDefaultsCacheFile();
534 if (def.exists()) {
535 try {
536 loadDefaults();
537 } catch (IOException | XMLStreamException | SAXException e) {
538 Logging.error(e);
539 Logging.warn(tr("Failed to load defaults cache file: {0}", def));
540 defaultsMap.clear();
541 if (!def.delete()) {
542 Logging.warn(tr("Failed to delete faulty defaults cache file: {0}", def));
543 }
544 }
545 }
546 }
547
548 /**
549 * Resets the preferences to their initial state. This resets all values and file associations.
550 * The default values and listeners are not removed.
551 * <p>
552 * It is meant to be called before {@link #init(boolean)}
553 * @since 10876
554 */
555 public void resetToInitialState() {
556 resetToDefault();
557 saveOnPut = true;
558 initSuccessful = false;
559 }
560
561 /**
562 * Reset all values stored in this map to the default values. This clears the preferences.
563 */
564 public final void resetToDefault() {
565 settingsMap.clear();
566 }
567
568 /**
569 * Set a value for a certain setting. The changed setting is saved to the preference file immediately.
570 * Due to caching mechanisms on modern operating systems and hardware, this shouldn't be a performance problem.
571 * @param key the unique identifier for the setting
572 * @param setting the value of the setting. In case it is null, the key-value entry will be removed.
573 * @return {@code true}, if something has changed (i.e. value is different than before)
574 */
575 @Override
576 public boolean putSetting(final String key, Setting<?> setting) {
577 CheckParameterUtil.ensureParameterNotNull(key);
578 if (setting != null && setting.getValue() == null)
579 throw new IllegalArgumentException("setting argument must not have null value");
580 Setting<?> settingOld;
581 Setting<?> settingCopy = null;
582 synchronized (this) {
583 if (setting == null) {
584 settingOld = settingsMap.remove(key);
585 if (settingOld == null)
586 return false;
587 } else {
588 settingOld = settingsMap.get(key);
589 if (setting.equals(settingOld))
590 return false;
591 if (settingOld == null && setting.equals(defaultsMap.get(key)))
592 return false;
593 settingCopy = setting.copy();
594 settingsMap.put(key, settingCopy);
595 }
596 if (saveOnPut) {
597 try {
598 save();
599 } catch (IOException | InvalidPathException e) {
600 File file = getPreferenceFile();
601 try {
602 file = file.getAbsoluteFile();
603 } catch (SecurityException ex) {
604 Logging.trace(ex);
605 }
606 Logging.log(Logging.LEVEL_WARN, tr("Failed to persist preferences to ''{0}''", file), e);
607 }
608 }
609 }
610 // Call outside of synchronized section in case some listener wait for other thread that wait for preference lock
611 firePreferenceChanged(key, settingOld, settingCopy);
612 return true;
613 }
614
615 /**
616 * Get a setting of any type
617 * @param key The key for the setting
618 * @param def The default value to use if it was not found
619 * @return The setting
620 */
621 public synchronized Setting<?> getSetting(String key, Setting<?> def) {
622 return getSetting(key, def, Setting.class);
623 }
624
625 /**
626 * Get settings value for a certain key and provide default a value.
627 * @param <T> the setting type
628 * @param key the identifier for the setting
629 * @param def the default value. For each call of getSetting() with a given key, the default value must be the same.
630 * <code>def</code> must not be null, but the value of <code>def</code> can be null.
631 * @param klass the setting type (same as T)
632 * @return the corresponding value if the property has been set before, {@code def} otherwise
633 */
634 @SuppressWarnings("unchecked")
635 @Override
636 public synchronized <T extends Setting<?>> T getSetting(String key, T def, Class<T> klass) {
637 CheckParameterUtil.ensureParameterNotNull(key);
638 CheckParameterUtil.ensureParameterNotNull(def);
639 Setting<?> oldDef = defaultsMap.get(key);
640 if (oldDef != null && oldDef.isNew() && oldDef.getValue() != null && def.getValue() != null && !def.equals(oldDef)) {
641 Logging.info("Defaults for " + key + " differ: " + def + " != " + defaultsMap.get(key));
642 }
643 if (def.getValue() != null || oldDef == null) {
644 Setting<?> defCopy = def.copy();
645 defCopy.setTime(System.currentTimeMillis() / 1000);
646 defCopy.setNew(true);
647 defaultsMap.put(key, defCopy);
648 }
649 Setting<?> prop = settingsMap.get(key);
650 if (klass.isInstance(prop)) {
651 return (T) prop;
652 } else {
653 return def;
654 }
655 }
656
657 @Override
658 public Set<String> getKeySet() {
659 return Collections.unmodifiableSet(settingsMap.keySet());
660 }
661
662 @Override
663 public Map<String, Setting<?>> getAllSettings() {
664 return new TreeMap<>(settingsMap);
665 }
666
667 /**
668 * Gets a map of all currently known defaults
669 * @return The map (key/setting)
670 */
671 public Map<String, Setting<?>> getAllDefaults() {
672 return new TreeMap<>(defaultsMap);
673 }
674
675 /**
676 * Replies the collection of plugin site URLs from where plugin lists can be downloaded.
677 * @return the collection of plugin site URLs
678 * @see #getOnlinePluginSites
679 */
680 public Collection<String> getPluginSites() {
681 return getList("pluginmanager.sites", Collections.singletonList(Config.getUrls().getJOSMWebsite()+"/pluginicons%<?plugins=>"));
682 }
683
684 /**
685 * Returns the list of plugin sites available according to offline mode settings.
686 * @return the list of available plugin sites
687 * @since 8471
688 */
689 public Collection<String> getOnlinePluginSites() {
690 Collection<String> pluginSites = new ArrayList<>(getPluginSites());
691 for (Iterator<String> it = pluginSites.iterator(); it.hasNext();) {
692 try {
693 OnlineResource.JOSM_WEBSITE.checkOfflineAccess(it.next(), Config.getUrls().getJOSMWebsite());
694 } catch (OfflineAccessException ex) {
695 Logging.log(Logging.LEVEL_WARN, ex);
696 it.remove();
697 }
698 }
699 return pluginSites;
700 }
701
702 /**
703 * Sets the collection of plugin site URLs.
704 *
705 * @param sites the site URLs
706 */
707 public void setPluginSites(Collection<String> sites) {
708 putList("pluginmanager.sites", new ArrayList<>(sites));
709 }
710
711 /**
712 * Returns XML describing these preferences.
713 * @param nopass if password must be excluded
714 * @return XML
715 */
716 public String toXML(boolean nopass) {
717 return toXML(settingsMap.entrySet(), nopass, false);
718 }
719
720 /**
721 * Returns XML describing the given preferences.
722 * @param settings preferences settings
723 * @param nopass if password must be excluded
724 * @param defaults true, if default values are converted to XML, false for
725 * regular preferences
726 * @return XML
727 */
728 public String toXML(Collection<Entry<String, Setting<?>>> settings, boolean nopass, boolean defaults) {
729 try (
730 StringWriter sw = new StringWriter();
731 PreferencesWriter prefWriter = new PreferencesWriter(new PrintWriter(sw), nopass, defaults)
732 ) {
733 prefWriter.write(settings);
734 sw.flush();
735 return sw.toString();
736 } catch (IOException e) {
737 Logging.error(e);
738 return null;
739 }
740 }
741
742 /**
743 * Removes obsolete preference settings. If you throw out a once-used preference
744 * setting, add it to the list here with an expiry date (written as comment). If you
745 * see something with an expiry date in the past, remove it from the list.
746 * @param loadedVersion JOSM version when the preferences file was written
747 */
748 private void removeObsolete(int loadedVersion) {
749 Logging.trace("Remove obsolete preferences for version {0}", Integer.toString(loadedVersion));
750 for (String key : OBSOLETE_PREF_KEYS) {
751 if (settingsMap.containsKey(key)) {
752 settingsMap.remove(key);
753 Logging.info(tr("Preference setting {0} has been removed since it is no longer used.", key));
754 }
755 }
756 }
757
758 /**
759 * Enables or not the preferences file auto-save mechanism (save each time a setting is changed).
760 * This behaviour is enabled by default.
761 * @param enable if {@code true}, makes JOSM save preferences file each time a setting is changed
762 * @since 7085
763 */
764 public final void enableSaveOnPut(boolean enable) {
765 synchronized (this) {
766 saveOnPut = enable;
767 }
768 }
769}
Note: See TracBrowser for help on using the repository browser.