Ignore:
Timestamp:
2017-09-13T23:24:50+02:00 (3 years ago)
Author:
bastiK
Message:

see #15229 - use Config.getPref() wherever possible

Location:
trunk/src/org/openstreetmap/josm/gui
Files:
121 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/gui/ConditionalOptionPaneUtil.java

    r12841 r12846  
    1717import javax.swing.JRadioButton;
    1818
    19 import org.openstreetmap.josm.Main;
    2019import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     20import org.openstreetmap.josm.spi.preferences.Config;
    2121import org.openstreetmap.josm.tools.GBC;
    2222import org.openstreetmap.josm.tools.Utils;
     
    5757     */
    5858    public static int getDialogReturnValue(String prefKey) {
    59         return Utils.firstNonNull(
    60                 immediateChoices.get(prefKey),
     59        return Utils.firstNonNull(immediateChoices.get(prefKey),
    6160                sessionChoices.get(prefKey),
    62                 !Main.pref.getBoolean("message." + prefKey, true) ? Main.pref.getInt("message." + prefKey + ".value", -1) : -1
     61                !Config.getPref().getBoolean("message." + prefKey, true) ? Config.getPref().getInt("message." + prefKey + ".value", -1) : -1
    6362        );
    6463    }
     
    239238                    break;
    240239                case PERMANENT:
    241                     Main.pref.putBoolean("message." + prefKey, false);
    242                     Main.pref.putInt("message." + prefKey + ".value", value);
     240                    Config.getPref().putBoolean("message." + prefKey, false);
     241                    Config.getPref().putInt("message." + prefKey + ".value", value);
    243242                    break;
    244243            }
  • trunk/src/org/openstreetmap/josm/gui/GettingStarted.java

    r12841 r12846  
    2929import org.openstreetmap.josm.io.CacheCustomContent;
    3030import org.openstreetmap.josm.io.OnlineResource;
     31import org.openstreetmap.josm.spi.preferences.Config;
    3132import org.openstreetmap.josm.tools.LanguageInfo;
    3233import org.openstreetmap.josm.tools.Logging;
     
    9596            String motd = new WikiReader().readLang("StartupPage");
    9697            // Save this to prefs in case JOSM is updated so MOTD can be refreshed
    97             Main.pref.putInt("cache.motd.html.version", myVersion);
    98             Main.pref.put("cache.motd.html.java", myJava);
    99             Main.pref.put("cache.motd.html.lang", myLang);
     98            Config.getPref().putInt("cache.motd.html.version", myVersion);
     99            Config.getPref().put("cache.motd.html.java", myJava);
     100            Config.getPref().put("cache.motd.html.lang", myLang);
    100101            return motd.getBytes(StandardCharsets.UTF_8);
    101102        }
     
    115116            // 2. Cannot be written (e.g. while developing). Obviously we don't want to update
    116117            // everytime because of something we can't read.
    117             return (Main.pref.getInt("cache.motd.html.version", -999) == myVersion)
    118             && Main.pref.get("cache.motd.html.java").equals(myJava)
    119             && Main.pref.get("cache.motd.html.lang").equals(myLang);
     118            return (Config.getPref().getInt("cache.motd.html.version", -999) == myVersion)
     119            && Config.getPref().get("cache.motd.html.java").equals(myJava)
     120            && Config.getPref().get("cache.motd.html.lang").equals(myLang);
    120121        }
    121122    }
     
    146147        // Asynchronously get MOTD to speed-up JOSM startup
    147148        Thread t = new Thread((Runnable) () -> {
    148             if (!contentInitialized && Main.pref.getBoolean("help.displaymotd", true)) {
     149            if (!contentInitialized && Config.getPref().getBoolean("help.displaymotd", true)) {
    149150                try {
    150151                    content = new MotdContent().updateIfRequiredString();
  • trunk/src/org/openstreetmap/josm/gui/IconToggleButton.java

    r12841 r12846  
    1010import javax.swing.JToggleButton;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.actions.ExpertToggleAction;
    1413import org.openstreetmap.josm.actions.ExpertToggleAction.ExpertModeChangeListener;
     14import org.openstreetmap.josm.spi.preferences.Config;
    1515import org.openstreetmap.josm.tools.CheckParameterUtil;
    1616import org.openstreetmap.josm.tools.Destroyable;
     
    9393    @Override
    9494    public void applyButtonHiddenPreferences() {
    95         boolean alwaysHideDisabled = Main.pref.getBoolean("sidetoolbar.hideDisabledButtons", false);
     95        boolean alwaysHideDisabled = Config.getPref().getBoolean("sidetoolbar.hideDisabledButtons", false);
    9696        if (!isEnabled() && (hideIfDisabled || alwaysHideDisabled)) {
    9797            setVisible(false);  // hide because of disabled button
    9898        } else {
    9999            boolean hiddenFlag = false;
    100             String hiddenFlagStr = Main.pref.get(getPreferenceKey(), null);
     100            String hiddenFlagStr = Config.getPref().get(getPreferenceKey(), null);
    101101            if (hiddenFlagStr == null) {
    102102                if (isExpert && !ExpertToggleAction.isExpert()) {
     
    118118        if ((b && isExpert && !ExpertToggleAction.isExpert()) ||
    119119            (!b && isExpert && ExpertToggleAction.isExpert())) {
    120             Main.pref.put(getPreferenceKey(), null);
     120            Config.getPref().put(getPreferenceKey(), null);
    121121        } else {
    122             Main.pref.putBoolean(getPreferenceKey(), b);
     122            Config.getPref().putBoolean(getPreferenceKey(), b);
    123123        }
    124124    }
  • trunk/src/org/openstreetmap/josm/gui/MainFrame.java

    r12841 r12846  
    2020import javax.swing.JPanel;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
    2423import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
     
    2827import org.openstreetmap.josm.gui.layer.OsmDataLayer.LayerStateChangeListener;
    2928import org.openstreetmap.josm.gui.util.WindowGeometry;
     29import org.openstreetmap.josm.spi.preferences.Config;
    3030import org.openstreetmap.josm.tools.ImageProvider;
    3131import org.openstreetmap.josm.tools.Logging;
     
    110110            geometry.remember("gui.geometry");
    111111        }
    112         Main.pref.putBoolean("gui.maximized", (windowState & JFrame.MAXIMIZED_BOTH) != 0);
     112        Config.getPref().putBoolean("gui.maximized", (windowState & JFrame.MAXIMIZED_BOTH) != 0);
    113113    }
    114114
  • trunk/src/org/openstreetmap/josm/gui/MainMenu.java

    r12834 r12846  
    122122import org.openstreetmap.josm.gui.preferences.map.TaggingPresetPreference;
    123123import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetSearchPrimitiveDialog;
     124import org.openstreetmap.josm.spi.preferences.Config;
    124125import org.openstreetmap.josm.tools.Shortcut;
    125126
     
    799800        changesetManager.addButtonModel(mi.getModel());
    800801
    801         if (!Main.pref.getBoolean("audio.menuinvisible", false)) {
     802        if (!Config.getPref().getBoolean("audio.menuinvisible", false)) {
    802803            showAudioMenu(true);
    803804        }
    804805
    805         Main.pref.addPreferenceChangeListener(e -> {
     806        Config.getPref().addPreferenceChangeListener(e -> {
    806807            if ("audio.menuinvisible".equals(e.getKey())) {
    807808                showAudioMenu(!Boolean.parseBoolean(e.getNewValue().toString()));
  • trunk/src/org/openstreetmap/josm/gui/MapFrame.java

    r12841 r12846  
    4242import javax.swing.plaf.basic.BasicSplitPaneUI;
    4343
    44 import org.openstreetmap.josm.Main;
    4544import org.openstreetmap.josm.actions.LassoModeAction;
    4645import org.openstreetmap.josm.actions.mapmode.DeleteAction;
     
    8079import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
    8180import org.openstreetmap.josm.gui.util.AdvancedKeyPressDetector;
     81import org.openstreetmap.josm.spi.preferences.Config;
    8282import org.openstreetmap.josm.tools.Destroyable;
    8383import org.openstreetmap.josm.tools.GBC;
     
    295295        }
    296296
    297         if (Main.pref.getBoolean("debug.advanced-keypress-detector.enable", true)) {
     297        if (Config.getPref().getBoolean("debug.advanced-keypress-detector.enable", true)) {
    298298            keyDetector.register();
    299299        }
     
    345345        MainApplication.getLayerManager().removeActiveLayerChangeListener(this);
    346346        dialogsPanel.destroy();
    347         Main.pref.removePreferenceChangeListener(sidetoolbarPreferencesChangedListener);
     347        Config.getPref().removePreferenceChangeListener(sidetoolbarPreferencesChangedListener);
    348348        for (int i = 0; i < toolBarActions.getComponentCount(); ++i) {
    349349            if (toolBarActions.getComponent(i) instanceof Destroyable) {
     
    496496         * sideToolBar: add map modes icons
    497497         */
    498         if (Main.pref.getBoolean("sidetoolbar.mapmodes.visible", true)) {
     498        if (Config.getPref().getBoolean("sidetoolbar.mapmodes.visible", true)) {
    499499            toolBarActions.setAlignmentX(0.5f);
    500500            toolBarActions.setBorder(null);
     
    511511         * sideToolBar: add toggle dialogs icons
    512512         */
    513         if (Main.pref.getBoolean("sidetoolbar.toggledialogs.visible", true)) {
     513        if (Config.getPref().getBoolean("sidetoolbar.toggledialogs.visible", true)) {
    514514            ((JToolBar) sideToolBar).addSeparator(new Dimension(0, 18));
    515515            toolBarToggle.setAlignmentX(0.5f);
     
    534534         * sideToolBar: decide scroll- and visibility
    535535         */
    536         if (Main.pref.getBoolean("sidetoolbar.scrollable", true)) {
     536        if (Config.getPref().getBoolean("sidetoolbar.scrollable", true)) {
    537537            final ScrollViewport svp = new ScrollViewport(sideToolBar, ScrollViewport.VERTICAL_DIRECTION);
    538538            sideToolBar = svp;
    539539        }
    540         sideToolBar.setVisible(Main.pref.getBoolean("sidetoolbar.visible", true));
     540        sideToolBar.setVisible(Config.getPref().getBoolean("sidetoolbar.visible", true));
    541541        sidetoolbarPreferencesChangedListener = e -> {
    542542            if ("sidetoolbar.visible".equals(e.getKey())) {
    543                 sideToolBar.setVisible(Main.pref.getBoolean("sidetoolbar.visible"));
     543                sideToolBar.setVisible(Config.getPref().getBoolean("sidetoolbar.visible"));
    544544            }
    545545        };
    546         Main.pref.addPreferenceChangeListener(sidetoolbarPreferencesChangedListener);
     546        Config.getPref().addPreferenceChangeListener(sidetoolbarPreferencesChangedListener);
    547547
    548548        /**
     
    554554         * statusLine: add to panel
    555555         */
    556         if (statusLine != null && Main.pref.getBoolean("statusline.visible", true)) {
     556        if (statusLine != null && Config.getPref().getBoolean("statusline.visible", true)) {
    557557            panel.add(statusLine, BorderLayout.SOUTH);
    558558        }
     
    583583            public void actionPerformed(ActionEvent e) {
    584584                boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
    585                 Main.pref.putBoolean("sidetoolbar.always-visible", sel);
     585                Config.getPref().putBoolean("sidetoolbar.always-visible", sel);
    586586            }
    587587        });
     
    606606                        }, 0);
    607607                    }
    608                     doNotHide.setSelected(Main.pref.getBoolean("sidetoolbar.always-visible", true));
     608                    doNotHide.setSelected(Config.getPref().getBoolean("sidetoolbar.always-visible", true));
    609609                }
    610610
     
    625625                @Override
    626626                public void actionPerformed(ActionEvent e) {
    627                     Main.pref.putBoolean("sidetoolbar.visible", false);
     627                    Config.getPref().putBoolean("sidetoolbar.visible", false);
    628628                }
    629629            });
  • trunk/src/org/openstreetmap/josm/gui/MapMover.java

    r12639 r12846  
    2424import org.openstreetmap.josm.data.preferences.BooleanProperty;
    2525import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2627import org.openstreetmap.josm.tools.Destroyable;
    2728import org.openstreetmap.josm.tools.Pair;
     
    4849
    4950        JMapViewerUpdater() {
    50             Main.pref.addPreferenceChangeListener(this);
     51            Config.getPref().addPreferenceChangeListener(this);
    5152            updateJMapViewer();
    5253        }
  • trunk/src/org/openstreetmap/josm/gui/MapStatus.java

    r12841 r12846  
    7979import org.openstreetmap.josm.gui.widgets.ImageLabel;
    8080import org.openstreetmap.josm.gui.widgets.JosmTextField;
     81import org.openstreetmap.josm.spi.preferences.Config;
    8182import org.openstreetmap.josm.tools.Destroyable;
    8283import org.openstreetmap.josm.tools.GBC;
     
    100101public final class MapStatus extends JPanel implements Helpful, Destroyable, PreferenceChangedListener, SoMChangeListener {
    101102
    102     private final DecimalFormat DECIMAL_FORMAT = new DecimalFormat(Main.pref.get("statusbar.decimal-format", "0.0"));
     103    private final DecimalFormat DECIMAL_FORMAT = new DecimalFormat(Config.getPref().get("statusbar.decimal-format", "0.0"));
    103104    private static final AbstractProperty<Double> DISTANCE_THRESHOLD = new DoubleProperty("statusbar.distance-threshold", 0.01).cached();
    104105
     
    775776            public void actionPerformed(ActionEvent e) {
    776777                boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
    777                 Main.pref.putBoolean("statusbar.always-visible", sel);
     778                Config.getPref().putBoolean("statusbar.always-visible", sel);
    778779            }
    779780        });
     
    820821                    }
    821822                    separator.setVisible(distText.equals(invoker) || latText.equals(invoker) || lonText.equals(invoker));
    822                     doNotHide.setSelected(Main.pref.getBoolean("statusbar.always-visible", true));
     823                    doNotHide.setSelected(Config.getPref().getBoolean("statusbar.always-visible", true));
    823824                }
    824825
     
    914915        add(distText, GBC.std().insets(3, 0, 0, 0));
    915916
    916         if (Main.pref.getBoolean("statusbar.change-system-of-measurement-on-click", true)) {
     917        if (Config.getPref().getBoolean("statusbar.change-system-of-measurement-on-click", true)) {
    917918            distText.addMouseListener(new MouseAdapter() {
    918919                private final List<String> soms = new ArrayList<>(new TreeSet<>(SystemOfMeasurement.ALL_SYSTEMS.keySet()));
     
    945946        progressBar.addMouseListener(new ShowMonitorDialogMouseAdapter());
    946947
    947         Main.pref.addPreferenceChangeListener(this);
     948        Config.getPref().addPreferenceChangeListener(this);
    948949
    949950        mvComponentAdapter = new ComponentAdapter() {
     
    974975    public void updateSystemOfMeasurement(String newsom) {
    975976        SystemOfMeasurement.setSystemOfMeasurement(newsom);
    976         if (Main.pref.getBoolean("statusbar.notify.change-system-of-measurement", true)) {
     977        if (Config.getPref().getBoolean("statusbar.notify.change-system-of-measurement", true)) {
    977978            new Notification(tr("System of measurement changed to {0}", newsom))
    978979                .setDuration(Notification.TIME_SHORT)
     
    10791080        // Compute total length of selected way(s) until an arbitrary limit set to 250 ways
    10801081        // in order to prevent performance issue if a large number of ways are selected (old behaviour kept in that case, see #8403)
    1081         int maxWays = Math.max(1, Main.pref.getInt("selection.max-ways-for-statusline", 250));
     1082        int maxWays = Math.max(1, Config.getPref().getInt("selection.max-ways-for-statusline", 250));
    10821083        if (!ways.isEmpty() && ways.size() <= maxWays) {
    10831084            dist = 0.0;
     
    11061107    public void destroy() {
    11071108        SystemOfMeasurement.removeSoMChangeListener(this);
    1108         Main.pref.removePreferenceChangeListener(this);
     1109        Config.getPref().removePreferenceChangeListener(this);
    11091110        mv.removeComponentListener(mvComponentAdapter);
    11101111
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r12722 r12846  
    7676import org.openstreetmap.josm.gui.mappaint.MapPaintStyles.MapPaintSylesUpdateListener;
    7777import org.openstreetmap.josm.io.audio.AudioPlayer;
     78import org.openstreetmap.josm.spi.preferences.Config;
    7879import org.openstreetmap.josm.tools.JosmRuntimeException;
    7980import org.openstreetmap.josm.tools.Logging;
     
    277278        layerManager.addAndFireLayerChangeListener(this);
    278279        layerManager.addActiveLayerChangeListener(this);
    279         Main.pref.addPreferenceChangeListener(this);
     280        Config.getPref().addPreferenceChangeListener(this);
    280281
    281282        addComponentListener(new ComponentAdapter() {
     
    813814        layerManager.removeAndFireLayerChangeListener(this);
    814815        layerManager.removeActiveLayerChangeListener(this);
    815         Main.pref.removePreferenceChangeListener(this);
     816        Config.getPref().removePreferenceChangeListener(this);
    816817        SelectionEventManager.getInstance().removeSelectionListener(repaintSelectionChangedListener);
    817818        MultipolygonCache.getInstance().clear();
  • trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r12841 r12846  
    6060import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
    6161import org.openstreetmap.josm.gui.util.CursorManager;
     62import org.openstreetmap.josm.spi.preferences.Config;
    6263import org.openstreetmap.josm.tools.Logging;
    6364import org.openstreetmap.josm.tools.Utils;
     
    869870    private void pushZoomUndo(EastNorth center, double scale) {
    870871        Date now = new Date();
    871         if ((now.getTime() - zoomTimestamp.getTime()) > (Main.pref.getDouble("zoom.undo.delay", 1.0) * 1000)) {
     872        if ((now.getTime() - zoomTimestamp.getTime()) > (Config.getPref().getDouble("zoom.undo.delay", 1.0) * 1000)) {
    872873            zoomUndoBuffer.push(new ZoomData(center, scale));
    873             if (zoomUndoBuffer.size() > Main.pref.getInt("zoom.undo.max", 50)) {
     874            if (zoomUndoBuffer.size() > Config.getPref().getInt("zoom.undo.max", 50)) {
    874875                zoomUndoBuffer.remove(0);
    875876            }
     
    11441145
    11451146        if (ds != null) {
    1146             double snapDistanceSq = Main.pref.getInt("mappaint.segment.snap-distance", 10);
     1147            double snapDistanceSq = Config.getPref().getInt("mappaint.segment.snap-distance", 10);
    11471148            snapDistanceSq *= snapDistanceSq;
    11481149
    1149             for (Way w : ds.searchWays(getBBox(p, Main.pref.getInt("mappaint.segment.snap-distance", 10)))) {
     1150            for (Way w : ds.searchWays(getBBox(p, Config.getPref().getInt("mappaint.segment.snap-distance", 10)))) {
    11501151                if (!predicate.test(w)) {
    11511152                    continue;
  • trunk/src/org/openstreetmap/josm/gui/Notification.java

    r12841 r12846  
    1010import javax.swing.UIManager;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     13import org.openstreetmap.josm.spi.preferences.Config;
    1414
    1515/**
     
    4343     * E.g. "Please select at least one node".
    4444     */
    45     public static final int TIME_SHORT = Main.pref.getInt("notification-time-short-ms", 3000);
     45    public static final int TIME_SHORT = Config.getPref().getInt("notification-time-short-ms", 3000);
    4646
    4747    /**
    4848     * Short message of one or two lines (5 s).
    4949     */
    50     public static final int TIME_DEFAULT = Main.pref.getInt("notification-time-default-ms", 5000);
     50    public static final int TIME_DEFAULT = Config.getPref().getInt("notification-time-default-ms", 5000);
    5151
    5252    /**
    5353     * Somewhat longer message (10 s).
    5454     */
    55     public static final int TIME_LONG = Main.pref.getInt("notification-time-long-ms", 10_000);
     55    public static final int TIME_LONG = Config.getPref().getInt("notification-time-long-ms", 10_000);
    5656
    5757    /**
     
    5959     * (Make sure is still sensible to show as a notification)
    6060     */
    61     public static final int TIME_VERY_LONG = Main.pref.getInt("notification-time-very_long-ms", 20_000);
     61    public static final int TIME_VERY_LONG = Config.getPref().getInt("notification-time-very_long-ms", 20_000);
    6262
    6363    private Component content;
  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitDialog.java

    r12841 r12846  
    2020import javax.swing.UIManager;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.gui.progress.swing.PleaseWaitProgressMonitor.ProgressMonitorDialog;
    2423import org.openstreetmap.josm.gui.util.GuiHelper;
    2524import org.openstreetmap.josm.gui.widgets.JosmTextArea;
     25import org.openstreetmap.josm.spi.preferences.Config;
    2626import org.openstreetmap.josm.tools.GBC;
    2727import org.openstreetmap.josm.tools.ImageProvider;
     
    8282                int w = getWidth();
    8383                if (w > 200) {
    84                     Main.pref.putInt("progressdialog.size", w);
     84                    Config.getPref().putInt("progressdialog.size", w);
    8585                }
    8686            }
     
    9898        setDropTarget(null); // Workaround to JDK bug 7027598/7100524/7169912 (#8613)
    9999        pack();
    100         setSize(Main.pref.getInt("progressdialog.size", 600), getSize().height);
     100        setSize(Config.getPref().getInt("progressdialog.size", 600), getSize().height);
    101101    }
    102102
  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

    r12675 r12846  
    1111import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1212import org.openstreetmap.josm.gui.progress.ProgressMonitor.CancelListener;
     13import org.openstreetmap.josm.gui.progress.ProgressTaskId;
    1314import org.openstreetmap.josm.gui.progress.swing.PleaseWaitProgressMonitor;
    14 import org.openstreetmap.josm.gui.progress.ProgressTaskId;
    1515import org.openstreetmap.josm.io.OsmTransferException;
    1616import org.openstreetmap.josm.tools.CheckParameterUtil;
  • trunk/src/org/openstreetmap/josm/gui/autofilter/AutoFilterManager.java

    r12636 r12846  
    2121import java.util.regex.Pattern;
    2222
    23 import org.openstreetmap.josm.Main;
    2423import org.openstreetmap.josm.actions.mapmode.MapMode;
    2524import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
     
    5655import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
    5756import org.openstreetmap.josm.gui.widgets.OSDLabel;
     57import org.openstreetmap.josm.spi.preferences.Config;
    5858import org.openstreetmap.josm.tools.Logging;
    5959
     
    124124    private AutoFilterManager() {
    125125        MapFrame.addMapModeChangeListener(this);
    126         Main.pref.addPreferenceChangeListener(this);
     126        Config.getPref().addPreferenceChangeListener(this);
    127127        NavigatableComponent.addZoomChangeListener(this);
    128128        MainApplication.getLayerManager().addLayerChangeListener(this);
  • trunk/src/org/openstreetmap/josm/gui/bbox/SlippyMapBBoxChooser.java

    r12841 r12846  
    4444import org.openstreetmap.josm.gui.layer.AbstractCachedTileSourceLayer;
    4545import org.openstreetmap.josm.gui.layer.TMSLayer;
     46import org.openstreetmap.josm.spi.preferences.Config;
    4647import org.openstreetmap.josm.tools.Logging;
    4748
     
    151152        uncachedLoader = new OsmTileLoader(this);
    152153        uncachedLoader.headers.putAll(headers);
    153         setZoomContolsVisible(Main.pref.getBoolean("slippy_map_chooser.zoomcontrols", false));
     154        setZoomContolsVisible(Config.getPref().getBoolean("slippy_map_chooser.zoomcontrols", false));
    154155        setMapMarkerVisible(false);
    155156        setMinimumSize(new Dimension(350, 350 / 2));
     
    160161            setFileCacheEnabled(false);
    161162        } else {
    162             setFileCacheEnabled(Main.pref.getBoolean("slippy_map_chooser.file_cache", true));
    163         }
    164         setMaxTilesInMemory(Main.pref.getInt("slippy_map_chooser.max_tiles", 1000));
     163            setFileCacheEnabled(Config.getPref().getBoolean("slippy_map_chooser.file_cache", true));
     164        }
     165        setMaxTilesInMemory(Config.getPref().getInt("slippy_map_chooser.max_tiles", 1000));
    165166
    166167        List<TileSource> tileSources = getAllTileSources();
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagConflictResolver.java

    r12841 r12846  
    1414import javax.swing.JScrollPane;
    1515
    16 import org.openstreetmap.josm.Main;
     16import org.openstreetmap.josm.spi.preferences.Config;
    1717
    1818/**
     
    6060                cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
    6161        });
    62         cbShowTagsWithConflictsOnly.setSelected(
    63                 Main.pref.getBoolean(getClass().getName() + ".showTagsWithConflictsOnly", false)
     62        cbShowTagsWithConflictsOnly.setSelected(Config.getPref().getBoolean(getClass().getName() + ".showTagsWithConflictsOnly", false)
    6463        );
    6564        cbShowTagsWithMultiValuesOnly.addChangeListener(
    6665                e -> model.setShowTagsWithMultiValuesOnly(cbShowTagsWithMultiValuesOnly.isSelected())
    6766        );
    68         cbShowTagsWithMultiValuesOnly.setSelected(
    69                 Main.pref.getBoolean(getClass().getName() + ".showTagsWithMultiValuesOnly", false)
     67        cbShowTagsWithMultiValuesOnly.setSelected(Config.getPref().getBoolean(getClass().getName() + ".showTagsWithMultiValuesOnly", false)
    7068        );
    7169        cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
     
    7876     */
    7977    public void rememberPreferences() {
    80         Main.pref.putBoolean(getClass().getName() + ".showTagsWithConflictsOnly", cbShowTagsWithConflictsOnly.isSelected());
    81         Main.pref.putBoolean(getClass().getName() + ".showTagsWithMultiValuesOnly", cbShowTagsWithMultiValuesOnly.isSelected());
     78        Config.getPref().putBoolean(getClass().getName() + ".showTagsWithConflictsOnly", cbShowTagsWithConflictsOnly.isSelected());
     79        Config.getPref().putBoolean(getClass().getName() + ".showTagsWithMultiValuesOnly", cbShowTagsWithMultiValuesOnly.isSelected());
    8280    }
    8381
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r12841 r12846  
    5858import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    5959import org.openstreetmap.josm.io.OnlineResource;
     60import org.openstreetmap.josm.spi.preferences.Config;
    6061import org.openstreetmap.josm.tools.ImageProvider;
    6162import org.openstreetmap.josm.tools.Logging;
     
    165166        cbInSelectionOnly.setToolTipText(tr("<html>Select to show changesets for the currently selected objects only.<br>"
    166167                + "Unselect to show all changesets for objects in the current data layer.</html>"));
    167         cbInSelectionOnly.setSelected(Main.pref.getBoolean("changeset-dialog.for-selected-objects-only", false));
     168        cbInSelectionOnly.setSelected(Config.getPref().getBoolean("changeset-dialog.for-selected-objects-only", false));
    168169        return pnl;
    169170    }
     
    275276        @Override
    276277        public void itemStateChanged(ItemEvent e) {
    277             Main.pref.putBoolean("changeset-dialog.for-selected-objects-only", cbInSelectionOnly.isSelected());
     278            Config.getPref().putBoolean("changeset-dialog.for-selected-objects-only", cbInSelectionOnly.isSelected());
    278279            pnlList.removeAll();
    279280            if (cbInSelectionOnly.isSelected()) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterDialog.java

    r12799 r12846  
    4343import org.openstreetmap.josm.gui.MapFrame;
    4444import org.openstreetmap.josm.gui.MapFrame.MapModeChangeListener;
     45import org.openstreetmap.josm.gui.SideButton;
    4546import org.openstreetmap.josm.gui.util.MultikeyActionsHandler;
    4647import org.openstreetmap.josm.gui.util.MultikeyShortcutAction;
    47 import org.openstreetmap.josm.gui.SideButton;
    4848import org.openstreetmap.josm.tools.ImageProvider;
    4949import org.openstreetmap.josm.tools.InputMapUtils;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r12799 r12846  
    6666import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
    6767import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
     68import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
    6869import org.openstreetmap.josm.gui.util.MultikeyActionsHandler;
    6970import org.openstreetmap.josm.gui.util.MultikeyShortcutAction.MultikeyInfo;
    70 import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
    7171import org.openstreetmap.josm.gui.widgets.DisableShortcutsOnFocusGainedTextField;
    7272import org.openstreetmap.josm.gui.widgets.JosmTextField;
    7373import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    7474import org.openstreetmap.josm.gui.widgets.ScrollableTable;
     75import org.openstreetmap.josm.spi.preferences.Config;
    7576import org.openstreetmap.josm.tools.ImageProvider;
    7677import org.openstreetmap.josm.tools.InputMapUtils;
     
    538539                label.setFont(label.getFont().deriveFont(Font.BOLD));
    539540            }
    540             if (Main.pref.getBoolean("dialog.layer.colorname", true)) {
     541            if (Config.getPref().getBoolean("dialog.layer.colorname", true)) {
    541542                AbstractProperty<Color> prop = layer.getColorProperty();
    542543                Color c = prop == null ? null : prop.get();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/MapPaintDialog.java

    r12831 r12846  
    6464import org.openstreetmap.josm.gui.mappaint.MapPaintStyles.MapPaintSylesUpdateListener;
    6565import org.openstreetmap.josm.gui.mappaint.StyleSetting;
     66import org.openstreetmap.josm.gui.mappaint.StyleSettingGuiFactory;
    6667import org.openstreetmap.josm.gui.mappaint.StyleSource;
    6768import org.openstreetmap.josm.gui.mappaint.loader.MapPaintStyleLoader;
    6869import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
    6970import org.openstreetmap.josm.gui.preferences.map.MapPaintPreference;
    70 import org.openstreetmap.josm.gui.mappaint.StyleSettingGuiFactory;
    7171import org.openstreetmap.josm.gui.util.FileFilterAllFiles;
    7272import org.openstreetmap.josm.gui.util.GuiHelper;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/OsmIdSelectionDialog.java

    r12841 r12846  
    2727import javax.swing.plaf.basic.BasicComboBoxEditor;
    2828
    29 import org.openstreetmap.josm.Main;
    3029import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    3130import org.openstreetmap.josm.data.osm.PrimitiveId;
     
    3837import org.openstreetmap.josm.gui.widgets.OsmIdTextField;
    3938import org.openstreetmap.josm.gui.widgets.OsmPrimitiveTypesComboBox;
     39import org.openstreetmap.josm.spi.preferences.Config;
    4040import org.openstreetmap.josm.tools.Utils;
    4141
     
    180180    protected void restorePrimitivesHistory(HistoryComboBox cbHistory) {
    181181        List<String> cmtHistory = new LinkedList<>(
    182                 Main.pref.getList(getClass().getName() + ".primitivesHistory", new LinkedList<String>()));
     182                Config.getPref().getList(getClass().getName() + ".primitivesHistory", new LinkedList<String>()));
    183183        // we have to reverse the history, because ComboBoxHistory will reverse it again in addElement()
    184184        Collections.reverse(cmtHistory);
     
    193193    protected void remindPrimitivesHistory(HistoryComboBox cbHistory) {
    194194        cbHistory.addCurrentItemToHistory();
    195         Main.pref.putList(getClass().getName() + ".primitivesHistory", cbHistory.getHistory());
     195        Config.getPref().putList(getClass().getName() + ".primitivesHistory", cbHistory.getHistory());
    196196    }
    197197
     
    208208    public void setupDialog() {
    209209        setContent(panel, false);
    210         cbType.setSelectedIndex(Main.pref.getInt("downloadprimitive.lasttype", 0));
     210        cbType.setSelectedIndex(Config.getPref().getInt("downloadprimitive.lasttype", 0));
    211211        tfId.setType(cbType.getType());
    212         if (Main.pref.getBoolean("downloadprimitive.autopaste", true)) {
     212        if (Config.getPref().getBoolean("downloadprimitive.autopaste", true)) {
    213213            tryToPasteFromClipboard(tfId, cbType);
    214214        }
     
    221221        String buf = ClipboardUtils.getClipboardStringContent();
    222222        if (buf == null || buf.isEmpty()) return;
    223         if (buf.length() > Main.pref.getInt("downloadprimitive.max-autopaste-length", 2000)) return;
     223        if (buf.length() > Config.getPref().getInt("downloadprimitive.max-autopaste-length", 2000)) return;
    224224        final List<SimplePrimitiveId> ids = SimplePrimitiveId.fuzzyParse(buf);
    225225        if (!ids.isEmpty()) {
     
    244244    @Override public void windowClosed(WindowEvent e) {
    245245        if (e != null && e.getComponent() == this && getValue() == getContinueButtonIndex()) {
    246             Main.pref.putInt("downloadprimitive.lasttype", cbType.getSelectedIndex());
     246            Config.getPref().putInt("downloadprimitive.lasttype", cbType.getSelectedIndex());
    247247
    248248            if (!tfId.readIds()) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r12748 r12846  
    7777import org.openstreetmap.josm.gui.widgets.JosmTextField;
    7878import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
     79import org.openstreetmap.josm.spi.preferences.Config;
    7980import org.openstreetmap.josm.tools.ImageProvider;
    8081import org.openstreetmap.josm.tools.InputMapUtils;
     
    122123
    123124    private final transient HighlightHelper highlightHelper = new HighlightHelper();
    124     private final boolean highlightEnabled = Main.pref.getBoolean("draw.target-highlight", true);
     125    private final boolean highlightEnabled = Config.getPref().getBoolean("draw.target-highlight", true);
    125126    private final transient RecentRelationsAction recentRelationsAction;
    126127
  • trunk/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r12841 r12846  
    3838import javax.swing.event.ListSelectionListener;
    3939
    40 import org.openstreetmap.josm.Main;
    4140import org.openstreetmap.josm.actions.AbstractSelectAction;
    4241import org.openstreetmap.josm.actions.AutoScaleAction;
     
    5857import org.openstreetmap.josm.data.osm.event.DatasetEventManager;
    5958import org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode;
    60 import org.openstreetmap.josm.data.osm.search.SearchSetting;
    6159import org.openstreetmap.josm.data.osm.event.NodeMovedEvent;
    6260import org.openstreetmap.josm.data.osm.event.PrimitivesAddedEvent;
     
    6664import org.openstreetmap.josm.data.osm.event.TagsChangedEvent;
    6765import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
     66import org.openstreetmap.josm.data.osm.search.SearchSetting;
    6867import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    6968import org.openstreetmap.josm.gui.MainApplication;
     
    8281import org.openstreetmap.josm.gui.widgets.ListPopupMenu;
    8382import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
     83import org.openstreetmap.josm.spi.preferences.Config;
    8484import org.openstreetmap.josm.tools.ImageProvider;
    8585import org.openstreetmap.josm.tools.InputMapUtils;
     
    192192    class MouseEventHandler extends PopupMenuLauncher {
    193193        private final HighlightHelper helper = new HighlightHelper();
    194         private final boolean highlightEnabled = Main.pref.getBoolean("draw.target-highlight", true);
     194        private final boolean highlightEnabled = Config.getPref().getBoolean("draw.target-highlight", true);
    195195
    196196        MouseEventHandler() {
     
    524524                }
    525525            }
    526             int maxsize = Main.pref.getInt("select.history-size", SELECTION_HISTORY_SIZE);
     526            int maxsize = Config.getPref().getInt("select.history-size", SELECTION_HISTORY_SIZE);
    527527            while (history.size() > maxsize) {
    528528                history.removeLast();
     
    662662         */
    663663        public synchronized void sort() {
    664             if (selection.size() <= Main.pref.getInt("selection.no_sort_above", 100_000)) {
    665                 boolean quick = selection.size() > Main.pref.getInt("selection.fast_sort_above", 10_000);
    666                 Comparator<OsmPrimitive> c = Main.pref.getBoolean("selection.sort_relations_before_ways", true)
     664            if (selection.size() <= Config.getPref().getInt("selection.no_sort_above", 100_000)) {
     665                boolean quick = selection.size() > Config.getPref().getInt("selection.fast_sort_above", 10_000);
     666                Comparator<OsmPrimitive> c = Config.getPref().getBoolean("selection.sort_relations_before_ways", true)
    667667                        ? OsmPrimitiveComparator.orderingRelationsWaysNodes()
    668668                        : OsmPrimitiveComparator.orderingWaysRelationsNodes();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r12841 r12846  
    6969import org.openstreetmap.josm.gui.util.WindowGeometry.WindowGeometryException;
    7070import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
     71import org.openstreetmap.josm.spi.preferences.Config;
    7172import org.openstreetmap.josm.tools.Destroyable;
    7273import org.openstreetmap.josm.tools.GBC;
     
    245246        toggleAction.putValue("help", helpId.substring(0, helpId.length()-6));
    246247
    247         isShowing = Main.pref.getBoolean(preferencePrefix+".visible", defShow);
    248         isDocked = Main.pref.getBoolean(preferencePrefix+".docked", true);
    249         isCollapsed = Main.pref.getBoolean(preferencePrefix+".minimized", false);
     248        isShowing = Config.getPref().getBoolean(preferencePrefix+".visible", defShow);
     249        isDocked = Config.getPref().getBoolean(preferencePrefix+".docked", true);
     250        isCollapsed = Config.getPref().getBoolean(preferencePrefix+".minimized", false);
    250251        buttonHiding = propButtonHiding.get();
    251252
     
    257258
    258259        MainApplication.redirectToMainContentPane(this);
    259         Main.pref.addPreferenceChangeListener(this);
     260        Config.getPref().addPreferenceChangeListener(this);
    260261
    261262        registerInWindowMenu();
     
    468469        }
    469470        Toolkit.getDefaultToolkit().removeAWTEventListener(this);
    470         Main.pref.removePreferenceChangeListener(this);
     471        Config.getPref().removePreferenceChangeListener(this);
    471472        destroyComponents(this, false);
    472473    }
     
    773774    protected void setIsShowing(boolean val) {
    774775        isShowing = val;
    775         Main.pref.putBoolean(preferencePrefix+".visible", val);
     776        Config.getPref().putBoolean(preferencePrefix+".visible", val);
    776777        stateChanged();
    777778    }
     
    782783        }
    783784        isDocked = val;
    784         Main.pref.putBoolean(preferencePrefix+".docked", val);
     785        Config.getPref().putBoolean(preferencePrefix+".docked", val);
    785786        stateChanged();
    786787    }
     
    788789    protected void setIsCollapsed(boolean val) {
    789790        isCollapsed = val;
    790         Main.pref.putBoolean(preferencePrefix+".minimized", val);
     791        Config.getPref().putBoolean(preferencePrefix+".minimized", val);
    791792        stateChanged();
    792793    }
     
    925926                    continue;
    926927                }
    927                 final JPanel buttonRowPanel = new JPanel(Main.pref.getBoolean("dialog.align.left", false)
     928                final JPanel buttonRowPanel = new JPanel(Config.getPref().getBoolean("dialog.align.left", false)
    928929                        ? new FlowLayout(FlowLayout.LEFT) : new GridLayout(1, buttonRow.size()));
    929930                buttonsPanel.add(buttonRowPanel);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

    r12649 r12846  
    5858import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    5959import org.openstreetmap.josm.io.OsmTransferException;
     60import org.openstreetmap.josm.spi.preferences.Config;
    6061import org.openstreetmap.josm.tools.ImageProvider;
    6162import org.openstreetmap.josm.tools.InputMapUtils;
     
    493494                    ds.setSelected(sel);
    494495                }
    495                 if (Main.pref.getBoolean("validator.autozoom", false)) {
     496                if (Config.getPref().getBoolean("validator.autozoom", false)) {
    496497                    AutoScaleAction.zoomTo(sel);
    497498                }
     
    573574     */
    574575    public void updateSelection(Collection<? extends OsmPrimitive> newSelection) {
    575         if (!Main.pref.getBoolean(ValidatorPrefHelper.PREF_FILTER_BY_SELECTION, false))
     576        if (!Config.getPref().getBoolean(ValidatorPrefHelper.PREF_FILTER_BY_SELECTION, false))
    576577            return;
    577578        if (newSelection.isEmpty()) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/SingleChangesetDownloadPanel.java

    r10494 r12846  
    2222import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    2323import org.openstreetmap.josm.io.OnlineResource;
     24import org.openstreetmap.josm.spi.preferences.Config;
    2425import org.openstreetmap.josm.tools.ImageProvider;
    2526
     
    6061        add(btn);
    6162
    62         if (Main.pref.getBoolean("downloadchangeset.autopaste", true)) {
     63        if (Config.getPref().getBoolean("downloadchangeset.autopaste", true)) {
    6364            tfChangesetId.tryToPasteFromClipboard();
    6465        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/AdvancedChangesetQueryPanel.java

    r12841 r12846  
    1515import javax.swing.JScrollPane;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.gui.util.GuiHelper;
    1918import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    2019import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
    2120import org.openstreetmap.josm.io.ChangesetQuery;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2222
    2323/**
     
    209209     */
    210210    public void rememberSettings() {
    211         Main.pref.putBoolean("changeset-query.advanced.user-restrictions", cbUserRestriction.isSelected());
    212         Main.pref.putBoolean("changeset-query.advanced.open-restrictions", cbOpenAndCloseRestrictions.isSelected());
    213         Main.pref.putBoolean("changeset-query.advanced.time-restrictions", cbTimeRestrictions.isSelected());
    214         Main.pref.putBoolean("changeset-query.advanced.bbox-restrictions", cbBoundingBoxRestriction.isSelected());
     211        Config.getPref().putBoolean("changeset-query.advanced.user-restrictions", cbUserRestriction.isSelected());
     212        Config.getPref().putBoolean("changeset-query.advanced.open-restrictions", cbOpenAndCloseRestrictions.isSelected());
     213        Config.getPref().putBoolean("changeset-query.advanced.time-restrictions", cbTimeRestrictions.isSelected());
     214        Config.getPref().putBoolean("changeset-query.advanced.bbox-restrictions", cbBoundingBoxRestriction.isSelected());
    215215
    216216        pnlUserRestriction.rememberSettings();
     
    223223     */
    224224    public void restoreFromSettings() {
    225         cbUserRestriction.setSelected(Main.pref.getBoolean("changeset-query.advanced.user-restrictions", false));
    226         cbOpenAndCloseRestrictions.setSelected(Main.pref.getBoolean("changeset-query.advanced.open-restrictions", false));
    227         cbTimeRestrictions.setSelected(Main.pref.getBoolean("changeset-query.advanced.time-restrictions", false));
    228         cbBoundingBoxRestriction.setSelected(Main.pref.getBoolean("changeset-query.advanced.bbox-restrictions", false));
     225        cbUserRestriction.setSelected(Config.getPref().getBoolean("changeset-query.advanced.user-restrictions", false));
     226        cbOpenAndCloseRestrictions.setSelected(Config.getPref().getBoolean("changeset-query.advanced.open-restrictions", false));
     227        cbTimeRestrictions.setSelected(Config.getPref().getBoolean("changeset-query.advanced.time-restrictions", false));
     228        cbBoundingBoxRestriction.setSelected(Config.getPref().getBoolean("changeset-query.advanced.bbox-restrictions", false));
    229229    }
    230230
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/BasicChangesetQueryPanel.java

    r12841 r12846  
    1919import javax.swing.JRadioButton;
    2020
    21 import org.openstreetmap.josm.Main;
    2221import org.openstreetmap.josm.data.Bounds;
    2322import org.openstreetmap.josm.data.UserIdentityManager;
     
    2726import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    2827import org.openstreetmap.josm.io.ChangesetQuery;
     28import org.openstreetmap.josm.spi.preferences.Config;
    2929import org.openstreetmap.josm.tools.Logging;
    3030
     
    187187        BasicQuery q = getSelectedQuery();
    188188        if (q == null) {
    189             Main.pref.put("changeset-query.basic.query", null);
    190         } else {
    191             Main.pref.put("changeset-query.basic.query", q.toString());
    192         }
    193         Main.pref.putBoolean("changeset-query.basic.my-changesets-only", cbMyChangesetsOnly.isSelected());
     189            Config.getPref().put("changeset-query.basic.query", null);
     190        } else {
     191            Config.getPref().put("changeset-query.basic.query", q.toString());
     192        }
     193        Config.getPref().putBoolean("changeset-query.basic.my-changesets-only", cbMyChangesetsOnly.isSelected());
    194194    }
    195195
     
    199199    public void restoreFromPreferences() {
    200200        BasicQuery q;
    201         String value = Main.pref.get("changeset-query.basic.query", null);
     201        String value = Config.getPref().get("changeset-query.basic.query", null);
    202202        if (value == null) {
    203203            q = BasicQuery.MOST_RECENT_CHANGESETS;
     
    212212        }
    213213        rbQueries.get(q).setSelected(true);
    214         boolean mineOnly = Main.pref.getBoolean("changeset-query.basic.my-changesets-only", false);
     214        boolean mineOnly = Config.getPref().getBoolean("changeset-query.basic.my-changesets-only", false);
    215215        mineOnly = mineOnly || q.equals(BasicQuery.MY_OPEN_CHANGESETS);
    216216        cbMyChangesetsOnly.setSelected(mineOnly);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/OpenAndCloseStateRestrictionPanel.java

    r11330 r12846  
    1313import javax.swing.JRadioButton;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    1716import org.openstreetmap.josm.io.ChangesetQuery;
     17import org.openstreetmap.josm.spi.preferences.Config;
    1818
    1919/**
     
    109109    public void rememberSettings() {
    110110        if (rbBoth.isSelected()) {
    111             Main.pref.put(PREF_QUERY_TYPE, "both");
     111            Config.getPref().put(PREF_QUERY_TYPE, "both");
    112112        } else if (rbOpenOnly.isSelected()) {
    113             Main.pref.put(PREF_QUERY_TYPE, "open");
     113            Config.getPref().put(PREF_QUERY_TYPE, "open");
    114114        } else if (rbClosedOnly.isSelected()) {
    115             Main.pref.put(PREF_QUERY_TYPE, "closed");
     115            Config.getPref().put(PREF_QUERY_TYPE, "closed");
    116116        }
    117117    }
     
    121121     */
    122122    public void restoreFromSettings() {
    123         String v = Main.pref.get(PREF_QUERY_TYPE, "open");
     123        String v = Config.getPref().get(PREF_QUERY_TYPE, "open");
    124124        rbBoth.setSelected("both".equals(v));
    125125        rbOpenOnly.setSelected("open".equals(v));
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/TimeRestrictionPanel.java

    r11326 r12846  
    2222import javax.swing.JRadioButton;
    2323
    24 import org.openstreetmap.josm.Main;
    2524import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2625import org.openstreetmap.josm.gui.help.HelpUtil;
     
    2928import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    3029import org.openstreetmap.josm.io.ChangesetQuery;
     30import org.openstreetmap.josm.spi.preferences.Config;
    3131
    3232/**
     
    296296        String prefRoot = "changeset-query.advanced.time-restrictions";
    297297        if (rbClosedAfter.isSelected()) {
    298             Main.pref.put(prefRoot + ".query-type", "closed-after");
     298            Config.getPref().put(prefRoot + ".query-type", "closed-after");
    299299        } else if (rbClosedAfterAndCreatedBefore.isSelected()) {
    300             Main.pref.put(prefRoot + ".query-type", "closed-after-created-before");
    301         }
    302         Main.pref.put(prefRoot + ".closed-after.date", tfClosedAfterDate1.getText());
    303         Main.pref.put(prefRoot + ".closed-after.time", tfClosedAfterTime1.getText());
    304         Main.pref.put(prefRoot + ".closed-created.closed.date", tfClosedAfterDate2.getText());
    305         Main.pref.put(prefRoot + ".closed-created.closed.time", tfClosedAfterTime2.getText());
    306         Main.pref.put(prefRoot + ".closed-created.created.date", tfCreatedBeforeDate.getText());
    307         Main.pref.put(prefRoot + ".closed-created.created.time", tfCreatedBeforeTime.getText());
     300            Config.getPref().put(prefRoot + ".query-type", "closed-after-created-before");
     301        }
     302        Config.getPref().put(prefRoot + ".closed-after.date", tfClosedAfterDate1.getText());
     303        Config.getPref().put(prefRoot + ".closed-after.time", tfClosedAfterTime1.getText());
     304        Config.getPref().put(prefRoot + ".closed-created.closed.date", tfClosedAfterDate2.getText());
     305        Config.getPref().put(prefRoot + ".closed-created.closed.time", tfClosedAfterTime2.getText());
     306        Config.getPref().put(prefRoot + ".closed-created.created.date", tfCreatedBeforeDate.getText());
     307        Config.getPref().put(prefRoot + ".closed-created.created.time", tfCreatedBeforeTime.getText());
    308308    }
    309309
     
    313313    public void restoreFromSettings() {
    314314        String prefRoot = "changeset-query.advanced.open-restrictions";
    315         String v = Main.pref.get(prefRoot + ".query-type", "closed-after");
     315        String v = Config.getPref().get(prefRoot + ".query-type", "closed-after");
    316316        rbClosedAfter.setSelected("closed-after".equals(v));
    317317        rbClosedAfterAndCreatedBefore.setSelected("closed-after-created-before".equals(v));
     
    319319            rbClosedAfter.setSelected(true);
    320320        }
    321         tfClosedAfterDate1.setText(Main.pref.get(prefRoot + ".closed-after.date", ""));
    322         tfClosedAfterTime1.setText(Main.pref.get(prefRoot + ".closed-after.time", ""));
    323         tfClosedAfterDate2.setText(Main.pref.get(prefRoot + ".closed-created.closed.date", ""));
    324         tfClosedAfterTime2.setText(Main.pref.get(prefRoot + ".closed-created.closed.time", ""));
    325         tfCreatedBeforeDate.setText(Main.pref.get(prefRoot + ".closed-created.created.date", ""));
    326         tfCreatedBeforeTime.setText(Main.pref.get(prefRoot + ".closed-created.created.time", ""));
     321        tfClosedAfterDate1.setText(Config.getPref().get(prefRoot + ".closed-after.date", ""));
     322        tfClosedAfterTime1.setText(Config.getPref().get(prefRoot + ".closed-after.time", ""));
     323        tfClosedAfterDate2.setText(Config.getPref().get(prefRoot + ".closed-created.closed.date", ""));
     324        tfClosedAfterTime2.setText(Config.getPref().get(prefRoot + ".closed-created.closed.time", ""));
     325        tfCreatedBeforeDate.setText(Config.getPref().get(prefRoot + ".closed-created.created.date", ""));
     326        tfCreatedBeforeTime.setText(Config.getPref().get(prefRoot + ".closed-created.created.time", ""));
    327327        if (!valClosedAfterDate1.isValid()) {
    328328            tfClosedAfterDate1.setText("");
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/UserRestrictionPanel.java

    r12743 r12846  
    1818import javax.swing.JRadioButton;
    1919
    20 import org.openstreetmap.josm.Main;
    2120import org.openstreetmap.josm.data.UserIdentityManager;
    2221import org.openstreetmap.josm.gui.HelpAwareOptionPane;
     
    2726import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    2827import org.openstreetmap.josm.io.ChangesetQuery;
     28import org.openstreetmap.josm.spi.preferences.Config;
    2929import org.openstreetmap.josm.tools.CheckParameterUtil;
    3030
     
    261261    public void rememberSettings() {
    262262        if (rbRestrictToMyself.isSelected()) {
    263             Main.pref.put(PREF_QUERY_TYPE, "mine");
     263            Config.getPref().put(PREF_QUERY_TYPE, "mine");
    264264        } else if (rbRestrictToUid.isSelected()) {
    265             Main.pref.put(PREF_QUERY_TYPE, "uid");
     265            Config.getPref().put(PREF_QUERY_TYPE, "uid");
    266266        } else if (rbRestrictToUserName.isSelected()) {
    267             Main.pref.put(PREF_QUERY_TYPE, "username");
    268         }
    269         Main.pref.put(PREF_ROOT + ".uid", tfUid.getText());
    270         Main.pref.put(PREF_ROOT + ".username", tfUserName.getText());
     267            Config.getPref().put(PREF_QUERY_TYPE, "username");
     268        }
     269        Config.getPref().put(PREF_ROOT + ".uid", tfUid.getText());
     270        Config.getPref().put(PREF_ROOT + ".username", tfUserName.getText());
    271271    }
    272272
     
    275275     */
    276276    public void restoreFromSettings() {
    277         String v = Main.pref.get(PREF_QUERY_TYPE, "mine");
     277        String v = Config.getPref().get(PREF_QUERY_TYPE, "mine");
    278278        if ("mine".equals(v)) {
    279279            UserIdentityManager im = UserIdentityManager.getInstance();
     
    288288            rbRestrictToUserName.setSelected(true);
    289289        }
    290         tfUid.setText(Main.pref.get(PREF_ROOT + ".uid", ""));
     290        tfUid.setText(Config.getPref().get(PREF_ROOT + ".uid", ""));
    291291        if (!valUid.isValid()) {
    292292            tfUid.setText("");
    293293        }
    294         tfUserName.setText(Main.pref.get(PREF_ROOT + ".username", ""));
     294        tfUserName.setText(Config.getPref().get(PREF_ROOT + ".username", ""));
    295295    }
    296296
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r12726 r12846  
    100100import org.openstreetmap.josm.gui.widgets.JosmTextField;
    101101import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
     102import org.openstreetmap.josm.spi.preferences.Config;
    102103import org.openstreetmap.josm.tools.AlphanumComparator;
    103104import org.openstreetmap.josm.tools.GBC;
     
    257258
    258259        // combine both tables and wrap them in a scrollPane
    259         boolean top = Main.pref.getBoolean("properties.presets.top", true);
     260        boolean top = Config.getPref().getBoolean("properties.presets.top", true);
    260261        if (top) {
    261262            bothTables.add(presets, GBC.std().fill(GBC.HORIZONTAL).insets(5, 2, 5, 2).anchor(GBC.NORTHWEST));
     
    295296        editHelper.loadTagsIfNeeded();
    296297
    297         Main.pref.addKeyPreferenceChangeListener("display.discardable-keys", preferenceListener);
     298        Config.getPref().addKeyPreferenceChangeListener("display.discardable-keys", preferenceListener);
    298299    }
    299300
     
    341342     */
    342343    private void setupBlankSpaceMenu() {
    343         if (Main.pref.getBoolean("properties.menu.add_edit_delete", true)) {
     344        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
    344345            blankSpaceMenuHandler.addAction(addAction);
    345346            PopupMenuLauncher launcher = new BlankSpaceMenuLauncher(blankSpaceMenu);
     
    354355    private void setupMembershipMenu() {
    355356        // setting up the membership table
    356         if (Main.pref.getBoolean("properties.menu.add_edit_delete", true)) {
     357        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
    357358            membershipMenuHandler.addAction(editAction);
    358359            membershipMenuHandler.addAction(deleteAction);
     
    406407     */
    407408    private void setupTagsMenu() {
    408         if (Main.pref.getBoolean("properties.menu.add_edit_delete", true)) {
     409        if (Config.getPref().getBoolean("properties.menu.add_edit_delete", true)) {
    409410            tagMenu.add(addAction);
    410411            tagMenu.add(editAction);
     
    541542    public void destroy() {
    542543        super.destroy();
    543         Main.pref.removeKeyPreferenceChangeListener("display.discardable-keys", preferenceListener);
     544        Config.getPref().removeKeyPreferenceChangeListener("display.discardable-keys", preferenceListener);
    544545        Container parent = pluginHook.getParent();
    545546        if (parent != null) {
     
    573574        tagData.setRowCount(0);
    574575
    575         final boolean displayDiscardableKeys = Main.pref.getBoolean("display.discardable-keys", false);
     576        final boolean displayDiscardableKeys = Config.getPref().getBoolean("display.discardable-keys", false);
    576577        final Map<String, Integer> keyCount = new HashMap<>();
    577578        final Map<String, String> tags = new HashMap<>();
     
    11361137        public void actionPerformed(ActionEvent e) {
    11371138            try {
    1138                 String base = Main.pref.get("url.openstreetmap-wiki", "https://wiki.openstreetmap.org/wiki/");
     1139                String base = Config.getPref().get("url.openstreetmap-wiki", "https://wiki.openstreetmap.org/wiki/");
    11391140                String lang = LanguageInfo.getWikiLanguagePrefix();
    11401141                final List<URI> uris = new ArrayList<>();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/RecentTagCollection.java

    r12841 r12846  
    99
    1010import org.openstreetmap.josm.data.osm.Tag;
     11import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    1112import org.openstreetmap.josm.data.osm.search.SearchParseError;
    1213import org.openstreetmap.josm.data.osm.search.SearchSetting;
    13 import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    1414import org.openstreetmap.josm.data.preferences.ListProperty;
    1515
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/TagEditHelper.java

    r12841 r12846  
    7373import org.openstreetmap.josm.data.osm.search.SearchSetting;
    7474import org.openstreetmap.josm.data.preferences.BooleanProperty;
    75 import org.openstreetmap.josm.data.preferences.ListProperty;
    7675import org.openstreetmap.josm.data.preferences.EnumProperty;
    7776import org.openstreetmap.josm.data.preferences.IntegerProperty;
     77import org.openstreetmap.josm.data.preferences.ListProperty;
    7878import org.openstreetmap.josm.data.preferences.StringProperty;
    7979import org.openstreetmap.josm.gui.ExtendedDialog;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r12758 r12846  
    100100import org.openstreetmap.josm.gui.tagging.presets.TaggingPresets;
    101101import org.openstreetmap.josm.gui.util.WindowGeometry;
     102import org.openstreetmap.josm.spi.preferences.Config;
    102103import org.openstreetmap.josm.tools.CheckParameterUtil;
    103104import org.openstreetmap.josm.tools.Logging;
     
    429430                }
    430431        );
    431         tfRole.setText(Main.pref.get("relation.editor.generic.lastrole", ""));
     432        tfRole.setText(Config.getPref().get("relation.editor.generic.lastrole", ""));
    432433        return tfRole;
    433434    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTable.java

    r12657 r12846  
    4040import org.openstreetmap.josm.gui.util.HighlightHelper;
    4141import org.openstreetmap.josm.gui.widgets.OsmPrimitivesTable;
     42import org.openstreetmap.josm.spi.preferences.Config;
    4243
    4344/**
     
    129130
    130131    private void initHighlighting() {
    131         highlightEnabled = Main.pref.getBoolean("draw.target-highlight", true);
     132        highlightEnabled = Config.getPref().getBoolean("draw.target-highlight", true);
    132133        if (!highlightEnabled) return;
    133134        getMemberTableModel().getSelectionModel().addListSelectionListener(highlighterListener);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AbstractRelationEditorAction.java

    r9665 r12846  
    88import javax.swing.event.TableModelListener;
    99
     10import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1011import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
    1112import org.openstreetmap.josm.gui.dialogs.relation.MemberTableModel;
    12 import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1313import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1414
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AddFromSelectionAction.java

    r9665 r12846  
    1111import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor;
    1212import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor.AddAbortException;
     13import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1314import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
    1415import org.openstreetmap.josm.gui.dialogs.relation.MemberTableModel;
    15 import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1616import org.openstreetmap.josm.gui.dialogs.relation.SelectionTable;
    1717import org.openstreetmap.josm.gui.dialogs.relation.SelectionTableModel;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/CancelAction.java

    r10791 r12846  
    1313import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    1414import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     15import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1516import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
    1617import org.openstreetmap.josm.gui.dialogs.relation.MemberTableModel;
    17 import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1818import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1919import org.openstreetmap.josm.gui.tagging.TagEditorModel;
    2020import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2122import org.openstreetmap.josm.tools.ImageProvider;
    2223import org.openstreetmap.josm.tools.InputMapUtils;
     
    6061            if (ret == 0) { //Yes, save the changes
    6162                //copied from OKAction.run()
    62                 Main.pref.put("relation.editor.generic.lastrole", tfRole.getText());
     63                Config.getPref().put("relation.editor.generic.lastrole", tfRole.getText());
    6364                if (!applyChanges())
    6465                    return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/OKAction.java

    r10424 r12846  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
     8import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    99import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
    1010import org.openstreetmap.josm.gui.dialogs.relation.MemberTableModel;
    11 import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    1211import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1312import org.openstreetmap.josm.gui.tagging.TagEditorModel;
    1413import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
     14import org.openstreetmap.josm.spi.preferences.Config;
    1515import org.openstreetmap.josm.tools.ImageProvider;
    1616
     
    4040    @Override
    4141    public void actionPerformed(ActionEvent e) {
    42         Main.pref.put("relation.editor.generic.lastrole", tfRole.getText());
     42        Config.getPref().put("relation.editor.generic.lastrole", tfRole.getText());
    4343        memberTable.stopHighlighting();
    4444        if (!applyChanges())
  • trunk/src/org/openstreetmap/josm/gui/download/BookmarkList.java

    r12841 r12846  
    2323import javax.swing.UIManager;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.actions.downloadtasks.ChangesetQueryTask;
    2726import org.openstreetmap.josm.data.Bounds;
     
    3938import org.openstreetmap.josm.gui.util.GuiHelper;
    4039import org.openstreetmap.josm.io.ChangesetQuery;
     40import org.openstreetmap.josm.spi.preferences.Config;
    4141import org.openstreetmap.josm.tools.ImageProvider;
    4242import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
     
    262262        }
    263263        // Then add manual bookmarks previously saved in local preferences
    264         Collection<Collection<String>> args = Main.pref.getArray("bookmarks", null);
     264        List<List<String>> args = Config.getPref().getListOfLists("bookmarks", null);
    265265        if (args != null) {
    266266            List<Bookmark> bookmarks = new LinkedList<>();
     
    315315            coll.add(Arrays.asList(array));
    316316        }
    317         Main.pref.putListOfLists("bookmarks", coll);
     317        Config.getPref().putListOfLists("bookmarks", coll);
    318318    }
    319319
  • trunk/src/org/openstreetmap/josm/gui/download/DownloadDialog.java

    r12733 r12846  
    5050import org.openstreetmap.josm.io.OnlineResource;
    5151import org.openstreetmap.josm.plugins.PluginHandler;
     52import org.openstreetmap.josm.spi.preferences.Config;
    5253import org.openstreetmap.josm.tools.GBC;
    5354import org.openstreetmap.josm.tools.ImageProvider;
     
    363364        DOWNLOAD_ZOOMTODATA.put(cbZoomToDownloadedData.isSelected());
    364365        if (currentBounds != null) {
    365             Main.pref.put("osm-download.bounds", currentBounds.encodeAsString(";"));
     366            Config.getPref().put("osm-download.bounds", currentBounds.encodeAsString(";"));
    366367        }
    367368    }
     
    406407     */
    407408    public static Bounds getSavedDownloadBounds() {
    408         String value = Main.pref.get("osm-download.bounds");
     409        String value = Config.getPref().get("osm-download.bounds");
    409410        if (!value.isEmpty()) {
    410411            try {
  • trunk/src/org/openstreetmap/josm/gui/download/DownloadObjectDialog.java

    r12841 r12846  
    1515import org.openstreetmap.josm.gui.dialogs.OsmIdSelectionDialog;
    1616import org.openstreetmap.josm.io.OnlineResource;
     17import org.openstreetmap.josm.spi.preferences.Config;
    1718
    1819/**
     
    5960    protected Collection<Component> getComponentsBeforeHelp() {
    6061        newLayer.setToolTipText(tr("Select if the data should be downloaded into a new layer"));
    61         newLayer.setSelected(Main.pref.getBoolean("download.newlayer"));
     62        newLayer.setSelected(Config.getPref().getBoolean("download.newlayer"));
    6263
    6364        referrers.setToolTipText(tr("Select if the referrers of the object should be downloaded as well, i.e.,"
    6465                + "parent relations and for nodes, additionally, parent ways"));
    65         referrers.setSelected(Main.pref.getBoolean("downloadprimitive.referrers", true));
     66        referrers.setSelected(Config.getPref().getBoolean("downloadprimitive.referrers", true));
    6667
    6768        fullRel.setToolTipText(tr("Select if the members of a relation should be downloaded as well"));
    68         fullRel.setSelected(Main.pref.getBoolean("downloadprimitive.full", true));
     69        fullRel.setSelected(Config.getPref().getBoolean("downloadprimitive.full", true));
    6970
    7071        cbType.addItemListener(e -> referrers.setText(cbType.getType() == OsmPrimitiveType.NODE
     
    103104        super.windowClosed(e);
    104105        if (e != null && e.getComponent() == this && getValue() == 1) {
    105             Main.pref.putBoolean("downloadprimitive.referrers", referrers.isSelected());
    106             Main.pref.putBoolean("downloadprimitive.full", fullRel.isSelected());
    107             Main.pref.putBoolean("download.newlayer", newLayer.isSelected());
     106            Config.getPref().putBoolean("downloadprimitive.referrers", referrers.isSelected());
     107            Config.getPref().putBoolean("downloadprimitive.full", fullRel.isSelected());
     108            Config.getPref().putBoolean("download.newlayer", newLayer.isSelected());
    108109        }
    109110    }
  • trunk/src/org/openstreetmap/josm/gui/download/DownloadSettings.java

    r12684 r12846  
    22package org.openstreetmap.josm.gui.download;
    33
     4import java.util.Optional;
     5
    46import org.openstreetmap.josm.data.Bounds;
    5 
    6 import java.util.Optional;
    77
    88/**
  • trunk/src/org/openstreetmap/josm/gui/download/OSMDownloadSource.java

    r12706 r12846  
    1919import javax.swing.event.ChangeListener;
    2020
    21 import org.openstreetmap.josm.Main;
    2221import org.openstreetmap.josm.actions.downloadtasks.AbstractDownloadTask;
    2322import org.openstreetmap.josm.actions.downloadtasks.DownloadGpsTask;
     
    3231import org.openstreetmap.josm.gui.MapFrame;
    3332import org.openstreetmap.josm.gui.util.GuiHelper;
     33import org.openstreetmap.josm.spi.preferences.Config;
    3434import org.openstreetmap.josm.tools.GBC;
    3535import org.openstreetmap.josm.tools.ImageProvider;
     
    298298            } else if (isDownloadNotes() && !isDownloadOsmData() && !isDownloadGpxData()) {
    299299                // see max_note_request_area in https://github.com/openstreetmap/openstreetmap-website/blob/master/config/example.application.yml
    300                 isAreaTooLarge = bbox.getArea() > Main.pref.getDouble("osm-server.max-request-area-notes", 25);
     300                isAreaTooLarge = bbox.getArea() > Config.getPref().getDouble("osm-server.max-request-area-notes", 25);
    301301            } else {
    302302                // see max_request_area in https://github.com/openstreetmap/openstreetmap-website/blob/master/config/example.application.yml
    303                 isAreaTooLarge = bbox.getArea() > Main.pref.getDouble("osm-server.max-request-area", 0.25);
     303                isAreaTooLarge = bbox.getArea() > Config.getPref().getDouble("osm-server.max-request-area", 0.25);
    304304            }
    305305
  • trunk/src/org/openstreetmap/josm/gui/download/OverpassQueryList.java

    r12841 r12846  
    4949import org.openstreetmap.josm.gui.widgets.JosmTextArea;
    5050import org.openstreetmap.josm.gui.widgets.SearchTextResultListPanel;
     51import org.openstreetmap.josm.spi.preferences.Config;
    5152import org.openstreetmap.josm.tools.GBC;
    5253import org.openstreetmap.josm.tools.Logging;
     
    254255        }
    255256
    256         Main.pref.putListOfMaps(PREFERENCE_ITEMS, toSave);
     257        Config.getPref().putListOfMaps(PREFERENCE_ITEMS, toSave);
    257258    }
    258259
     
    263264    private static Map<String, SelectorItem> restorePreferences() {
    264265        Collection<Map<String, String>> toRetrieve =
    265                 Main.pref.getListOfMaps(PREFERENCE_ITEMS, Collections.emptyList());
     266                Config.getPref().getListOfMaps(PREFERENCE_ITEMS, Collections.emptyList());
    266267        Map<String, SelectorItem> result = new HashMap<>();
    267268
  • trunk/src/org/openstreetmap/josm/gui/download/PlaceSelection.java

    r12841 r12846  
    5555import org.openstreetmap.josm.io.NameFinder.SearchResult;
    5656import org.openstreetmap.josm.io.OsmTransferException;
     57import org.openstreetmap.josm.spi.preferences.Config;
    5758import org.openstreetmap.josm.tools.GBC;
    5859import org.openstreetmap.josm.tools.HttpClient;
     
    105106        lpanel.add(new JLabel(tr("Choose the server for searching:")));
    106107        lpanel.add(server);
    107         String s = Main.pref.get("namefinder.server", SERVERS[0].name);
     108        String s = Config.getPref().get("namefinder.server", SERVERS[0].name);
    108109        for (int i = 0; i < SERVERS.length; ++i) {
    109110            if (SERVERS[i].name.equals(s)) {
     
    115116        cbSearchExpression = new HistoryComboBox();
    116117        cbSearchExpression.setToolTipText(tr("Enter a place name to search for"));
    117         List<String> cmtHistory = new LinkedList<>(Main.pref.getList(HISTORY_KEY, new LinkedList<String>()));
     118        List<String> cmtHistory = new LinkedList<>(Config.getPref().getList(HISTORY_KEY, new LinkedList<String>()));
    118119        Collections.reverse(cmtHistory);
    119120        cbSearchExpression.setPossibleItems(cmtHistory);
     
    189190                return;
    190191            cbSearchExpression.addCurrentItemToHistory();
    191             Main.pref.putList(HISTORY_KEY, cbSearchExpression.getHistory());
     192            Config.getPref().putList(HISTORY_KEY, cbSearchExpression.getHistory());
    192193            NameQueryTask task = new NameQueryTask(cbSearchExpression.getText());
    193194            MainApplication.worker.submit(task);
     
    227228            this.searchExpression = searchExpression;
    228229            useserver = (Server) server.getSelectedItem();
    229             Main.pref.put("namefinder.server", useserver.name);
     230            Config.getPref().put("namefinder.server", useserver.name);
    230231        }
    231232
  • trunk/src/org/openstreetmap/josm/gui/help/HelpUtil.java

    r12643 r12846  
    1414import org.openstreetmap.josm.actions.HelpAction;
    1515import org.openstreetmap.josm.gui.MainApplication;
     16import org.openstreetmap.josm.spi.preferences.Config;
    1617import org.openstreetmap.josm.tools.LanguageInfo;
    1718import org.openstreetmap.josm.tools.LanguageInfo.LocaleType;
     
    3334     */
    3435    public static String getWikiBaseUrl() {
    35         return Main.pref.get("help.baseurl", Main.getJOSMWebsite());
     36        return Config.getPref().get("help.baseurl", Main.getJOSMWebsite());
    3637    }
    3738
     
    132133        if (ret == null)
    133134            return ret;
    134         ret = '/' + ret + Main.pref.get("help.pathhelp", "/Help").replaceAll("^\\/+", ""); // remove leading /
     135        ret = '/' + ret + Config.getPref().get("help.pathhelp", "/Help").replaceAll("^\\/+", ""); // remove leading /
    135136        return ret.replaceAll("\\/+", "\\/"); // collapse sequences of //
    136137    }
  • trunk/src/org/openstreetmap/josm/gui/history/VersionTable.java

    r12841 r12846  
    3535import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    3636import org.openstreetmap.josm.io.XmlWriter;
     37import org.openstreetmap.josm.spi.preferences.Config;
    3738import org.openstreetmap.josm.tools.ImageProvider;
    3839import org.openstreetmap.josm.tools.OpenBrowser;
     
    341342        Object val = tbl.getColumnModel().getColumn(col).getHeaderValue();
    342343        Component comp = tcr.getTableCellRendererComponent(tbl, val, false, false, -1, col);
    343         maxwidth = Math.max(comp.getPreferredSize().width + Main.pref.getInt("table.header-inset", 0), maxwidth);
     344        maxwidth = Math.max(comp.getPreferredSize().width + Config.getPref().getInt("table.header-inset", 0), maxwidth);
    344345
    345346        int spacing = tbl.getIntercellSpacing().width;
  • trunk/src/org/openstreetmap/josm/gui/io/BasicUploadSettingsPanel.java

    r12841 r12846  
    2828import javax.swing.event.HyperlinkEvent;
    2929
    30 import org.openstreetmap.josm.Main;
    3130import org.openstreetmap.josm.data.osm.Changeset;
    3231import org.openstreetmap.josm.gui.MainApplication;
    3332import org.openstreetmap.josm.gui.widgets.HistoryComboBox;
    3433import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     34import org.openstreetmap.josm.spi.preferences.Config;
    3535import org.openstreetmap.josm.tools.CheckParameterUtil;
    3636import org.openstreetmap.josm.tools.GBC;
     
    7878        hcbUploadComment.setToolTipText(tr("Enter an upload comment"));
    7979        hcbUploadComment.setMaxTextLength(Changeset.MAX_CHANGESET_TAG_LENGTH);
    80         List<String> cmtHistory = new LinkedList<>(Main.pref.getList(HISTORY_KEY, new LinkedList<String>()));
     80        List<String> cmtHistory = new LinkedList<>(Config.getPref().getList(HISTORY_KEY, new LinkedList<String>()));
    8181        Collections.reverse(cmtHistory); // we have to reverse the history, because ComboBoxHistory will reverse it again in addElement()
    8282        hcbUploadComment.setPossibleItems(cmtHistory);
     
    100100        hcbUploadSource.setToolTipText(tr("Enter a source"));
    101101        hcbUploadSource.setMaxTextLength(Changeset.MAX_CHANGESET_TAG_LENGTH);
    102         List<String> sourceHistory = new LinkedList<>(Main.pref.getList(SOURCE_HISTORY_KEY, getDefaultSources()));
     102        List<String> sourceHistory = new LinkedList<>(Config.getPref().getList(SOURCE_HISTORY_KEY, getDefaultSources()));
    103103        Collections.reverse(sourceHistory); // we have to reverse the history, because ComboBoxHistory will reverse it again in addElement()
    104104        hcbUploadSource.setPossibleItems(sourceHistory);
     
    166166        // store the history of comments
    167167        hcbUploadComment.addCurrentItemToHistory();
    168         Main.pref.putList(HISTORY_KEY, hcbUploadComment.getHistory());
    169         Main.pref.putInt(HISTORY_LAST_USED_KEY, (int) (TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis())));
     168        Config.getPref().putList(HISTORY_KEY, hcbUploadComment.getHistory());
     169        Config.getPref().putInt(HISTORY_LAST_USED_KEY, (int) (TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis())));
    170170        // store the history of sources
    171171        hcbUploadSource.addCurrentItemToHistory();
    172         Main.pref.putList(SOURCE_HISTORY_KEY, hcbUploadSource.getHistory());
     172        Config.getPref().putList(SOURCE_HISTORY_KEY, hcbUploadSource.getHistory());
    173173    }
    174174
  • trunk/src/org/openstreetmap/josm/gui/io/ChangesetManagementPanel.java

    r12841 r12846  
    2323import javax.swing.event.ListDataListener;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.data.osm.Changeset;
    2726import org.openstreetmap.josm.data.osm.ChangesetCache;
     
    2928import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    3029import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     30import org.openstreetmap.josm.spi.preferences.Config;
    3131import org.openstreetmap.josm.tools.CheckParameterUtil;
    3232import org.openstreetmap.josm.tools.ImageProvider;
     
    156156        cbCloseAfterUpload.setToolTipText(tr("Select to close the changeset after the next upload"));
    157157        add(cbCloseAfterUpload, gc);
    158         cbCloseAfterUpload.setSelected(Main.pref.getBoolean("upload.changeset.close", true));
     158        cbCloseAfterUpload.setSelected(Config.getPref().getBoolean("upload.changeset.close", true));
    159159        cbCloseAfterUpload.addItemListener(new CloseAfterUploadItemStateListener());
    160160
     
    256256            case ItemEvent.SELECTED:
    257257                firePropertyChange(CLOSE_CHANGESET_AFTER_UPLOAD, false, true);
    258                 Main.pref.putBoolean("upload.changeset.close", true);
     258                Config.getPref().putBoolean("upload.changeset.close", true);
    259259                break;
    260260            case ItemEvent.DESELECTED:
    261261                firePropertyChange(CLOSE_CHANGESET_AFTER_UPLOAD, true, false);
    262                 Main.pref.putBoolean("upload.changeset.close", false);
     262                Config.getPref().putBoolean("upload.changeset.close", false);
    263263                break;
    264264            default: // Do nothing
  • trunk/src/org/openstreetmap/josm/gui/io/CredentialDialog.java

    r12821 r12846  
    4242import org.openstreetmap.josm.io.auth.AbstractCredentialsAgent;
    4343import org.openstreetmap.josm.io.auth.CredentialsAgentResponse;
     44import org.openstreetmap.josm.spi.preferences.Config;
    4445import org.openstreetmap.josm.tools.ImageProvider;
    4546import org.openstreetmap.josm.tools.InputMapUtils;
     
    355356            tfUserName.setToolTipText(tr("Please enter the user name for authenticating at your proxy server"));
    356357            tfPassword.setToolTipText(tr("Please enter the password for authenticating at your proxy server"));
    357             lblHeading.setText(
    358                     "<html>" + tr("Authenticating at the HTTP proxy ''{0}'' failed. Please enter a valid username and a valid password.",
    359                             Main.pref.get(DefaultProxySelector.PROXY_HTTP_HOST) + ':' +
    360                             Main.pref.get(DefaultProxySelector.PROXY_HTTP_PORT)) + "</html>");
     358            lblHeading.setText("<html>" + tr("Authenticating at the HTTP proxy ''{0}'' failed. Please enter a valid username and a valid password.",
     359                            Config.getPref().get(DefaultProxySelector.PROXY_HTTP_HOST) + ':' +
     360                            Config.getPref().get(DefaultProxySelector.PROXY_HTTP_PORT)) + "</html>");
    361361            lblWarning.setText("<html>" +
    362362                    tr("Warning: depending on the authentication method the proxy server uses the password may be transferred unencrypted.")
  • trunk/src/org/openstreetmap/josm/gui/io/CustomConfigurator.java

    r12841 r12846  
    5050import org.openstreetmap.josm.plugins.PluginInformation;
    5151import org.openstreetmap.josm.plugins.ReadLocalPluginInformationTask;
     52import org.openstreetmap.josm.spi.preferences.Config;
    5253import org.openstreetmap.josm.tools.LanguageInfo;
    5354import org.openstreetmap.josm.tools.Logging;
     
    400401                        MainApplication.worker.submit(pluginDownloadTask);
    401402                    }
    402                     List<String> pls = new ArrayList<>(Main.pref.getList("plugins"));
     403                    List<String> pls = new ArrayList<>(Config.getPref().getList("plugins"));
    403404                    for (PluginInformation pi2: toInstallPlugins) {
    404405                        if (!pls.contains(pi2.name)) {
     
    413414                        new File(Main.pref.getPluginsDirectory(), pi4.name+".jar").deleteOnExit();
    414415                    }
    415                     Main.pref.putList("plugins", pls);
     416                    Config.getPref().putList("plugins", pls);
    416417                });
    417418            }
  • trunk/src/org/openstreetmap/josm/gui/io/RecentlyOpenedFilesMenu.java

    r12841 r12846  
    1717import javax.swing.event.MenuListener;
    1818
    19 import org.openstreetmap.josm.Main;
    2019import org.openstreetmap.josm.actions.OpenFileAction.OpenFileTask;
    2120import org.openstreetmap.josm.gui.MainApplication;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2222import org.openstreetmap.josm.tools.ImageProvider;
    2323
     
    5858    private void rebuild() {
    5959        removeAll();
    60         Collection<String> fileHistory = Main.pref.getList("file-open.history");
     60        Collection<String> fileHistory = Config.getPref().getList("file-open.history");
    6161
    6262        for (final String file : fileHistory) {
     
    101101        @Override
    102102        public void actionPerformed(ActionEvent e) {
    103             Main.pref.putList("file-open.history", null);
     103            Config.getPref().putList("file-open.history", null);
    104104        }
    105105    }
  • trunk/src/org/openstreetmap/josm/gui/io/UploadDialog.java

    r12841 r12846  
    6060import org.openstreetmap.josm.io.UploadStrategy;
    6161import org.openstreetmap.josm.io.UploadStrategySpecification;
     62import org.openstreetmap.josm.spi.preferences.Config;
    6263import org.openstreetmap.josm.tools.GBC;
    6364import org.openstreetmap.josm.tools.ImageOverlay;
     
    252253        setMinimumSize(new Dimension(600, 350));
    253254
    254         Main.pref.addPreferenceChangeListener(this);
     255        Config.getPref().addPreferenceChangeListener(this);
    255256    }
    256257
     
    653654
    654655    private static String getLastChangesetTagFromHistory(String historyKey, List<String> def) {
    655         Collection<String> history = Main.pref.getList(historyKey, def);
    656         int age = (int) (System.currentTimeMillis() / 1000 - Main.pref.getInt(BasicUploadSettingsPanel.HISTORY_LAST_USED_KEY, 0));
     656        Collection<String> history = Config.getPref().getList(historyKey, def);
     657        int age = (int) (System.currentTimeMillis() / 1000 - Config.getPref().getInt(BasicUploadSettingsPanel.HISTORY_LAST_USED_KEY, 0));
    657658        if (history != null && age < Main.pref.getLong(BasicUploadSettingsPanel.HISTORY_MAX_AGE_KEY, TimeUnit.HOURS.toMillis(4))
    658659                && !history.isEmpty()) {
  • trunk/src/org/openstreetmap/josm/gui/io/UploadStrategySelectionPanel.java

    r12841 r12846  
    3131import javax.swing.event.DocumentListener;
    3232
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    3534import org.openstreetmap.josm.gui.widgets.JosmTextField;
     
    3938import org.openstreetmap.josm.io.UploadStrategy;
    4039import org.openstreetmap.josm.io.UploadStrategySpecification;
     40import org.openstreetmap.josm.spi.preferences.Config;
    4141import org.openstreetmap.josm.tools.Logging;
    4242
     
    323323        UploadStrategy strategy = UploadStrategy.getFromPreferences();
    324324        rbStrategy.get(strategy).setSelected(true);
    325         int chunkSize = Main.pref.getInt("osm-server.upload-strategy.chunk-size", 1);
     325        int chunkSize = Config.getPref().getInt("osm-server.upload-strategy.chunk-size", 1);
    326326        tfChunkSize.setText(Integer.toString(chunkSize));
    327327        updateNumRequestsLabels();
     
    337337        try {
    338338            chunkSize = Integer.parseInt(tfChunkSize.getText().trim());
    339             Main.pref.putInt("osm-server.upload-strategy.chunk-size", chunkSize);
     339            Config.getPref().putInt("osm-server.upload-strategy.chunk-size", chunkSize);
    340340        } catch (NumberFormatException e) {
    341341            // don't save invalid value to preferences
  • trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxExporter.java

    r12841 r12846  
    3636import org.openstreetmap.josm.io.Compression;
    3737import org.openstreetmap.josm.io.GpxWriter;
     38import org.openstreetmap.josm.spi.preferences.Config;
    3839import org.openstreetmap.josm.tools.CheckParameterUtil;
    3940import org.openstreetmap.josm.tools.GBC;
     
    110111        p.add(new JScrollPane(desc), GBC.eop().fill(GBC.BOTH));
    111112
    112         JCheckBox author = new JCheckBox(tr("Add author information"), Main.pref.getBoolean("lastAddAuthor", true));
     113        JCheckBox author = new JCheckBox(tr("Add author information"), Config.getPref().getBoolean("lastAddAuthor", true));
    113114        p.add(author, GBC.eol());
    114115
     
    162163        setCanceled(false);
    163164
    164         Main.pref.putBoolean("lastAddAuthor", author.isSelected());
     165        Config.getPref().putBoolean("lastAddAuthor", author.isSelected());
    165166        if (!authorName.getText().isEmpty()) {
    166             Main.pref.put("lastAuthorName", authorName.getText());
     167            Config.getPref().put("lastAuthorName", authorName.getText());
    167168        }
    168169        if (!copyright.getText().isEmpty()) {
    169             Main.pref.put("lastCopyright", copyright.getText());
     170            Config.getPref().put("lastCopyright", copyright.getText());
    170171        }
    171172
     
    231232            }
    232233            if (copyright.getText().isEmpty()) {
    233                 copyright.setText(Optional.ofNullable(data.getString(META_COPYRIGHT_LICENSE)).orElseGet(
    234                         () -> Main.pref.get("lastCopyright", "https://creativecommons.org/licenses/by-sa/2.5")));
     234                copyright.setText(Optional.ofNullable(data.getString(META_COPYRIGHT_LICENSE)).orElseGet(() -> Config.getPref().get("lastCopyright", "https://creativecommons.org/licenses/by-sa/2.5")));
    235235                copyright.setCaretPosition(0);
    236236            }
     
    280280            emailLabel.setEnabled(b);
    281281            if (b) {
    282                 authorName.setText(Optional.ofNullable(data.getString(META_AUTHOR_NAME)).orElseGet(() -> Main.pref.get("lastAuthorName")));
    283                 email.setText(Optional.ofNullable(data.getString(META_AUTHOR_EMAIL)).orElseGet(() -> Main.pref.get("lastAuthorEmail")));
     282                authorName.setText(Optional.ofNullable(data.getString(META_AUTHOR_NAME)).orElseGet(() -> Config.getPref().get("lastAuthorName")));
     283                email.setText(Optional.ofNullable(data.getString(META_AUTHOR_EMAIL)).orElseGet(() -> Config.getPref().get("lastAuthorEmail")));
    284284            } else {
    285285                authorName.setText("");
  • trunk/src/org/openstreetmap/josm/gui/io/importexport/GpxImporter.java

    r12671 r12846  
    1010import javax.swing.JOptionPane;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.actions.ExtensionFileFilter;
    1413import org.openstreetmap.josm.data.gpx.GpxData;
     
    2019import org.openstreetmap.josm.io.Compression;
    2120import org.openstreetmap.josm.io.GpxReader;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2222import org.openstreetmap.josm.tools.Logging;
    2323import org.xml.sax.SAXException;
     
    9595     */
    9696    public static ExtensionFileFilter getFileFilter() {
    97         return ExtensionFileFilter.newFilterWithArchiveExtensions(
    98             "gpx", Main.pref.get("save.extension.gpx", "gpx"), tr("GPX Files"), true);
     97        return ExtensionFileFilter.newFilterWithArchiveExtensions("gpx", Config.getPref().get("save.extension.gpx", "gpx"), tr("GPX Files"), true);
    9998    }
    10099
     
    148147            gpxLayer = new GpxLayer(data, gpxLayerName, data.storageFile != null);
    149148        }
    150         if (Main.pref.getBoolean("marker.makeautomarkers", true) && !data.waypoints.isEmpty()) {
     149        if (Config.getPref().getBoolean("marker.makeautomarkers", true) && !data.waypoints.isEmpty()) {
    151150            markerLayer = new MarkerLayer(data, markerLayerName, data.storageFile, gpxLayer);
    152151            if (markerLayer.data.isEmpty()) {
  • trunk/src/org/openstreetmap/josm/gui/io/importexport/NMEAImporter.java

    r12671 r12846  
    2323import org.openstreetmap.josm.io.Compression;
    2424import org.openstreetmap.josm.io.nmea.NmeaReader;
     25import org.openstreetmap.josm.spi.preferences.Config;
    2526
    2627/**
     
    5556                GuiHelper.runInEDT(() -> {
    5657                    MainApplication.getLayerManager().addLayer(gpxLayer);
    57                     if (Main.pref.getBoolean("marker.makeautomarkers", true)) {
     58                    if (Config.getPref().getBoolean("marker.makeautomarkers", true)) {
    5859                        MarkerLayer ml = new MarkerLayer(r.data, tr("Markers from {0}", fn), fileFinal, gpxLayer);
    5960                        if (!ml.data.isEmpty()) {
  • trunk/src/org/openstreetmap/josm/gui/io/importexport/OsmExporter.java

    r12800 r12846  
    2222import org.openstreetmap.josm.io.OsmWriter;
    2323import org.openstreetmap.josm.io.OsmWriterFactory;
     24import org.openstreetmap.josm.spi.preferences.Config;
    2425import org.openstreetmap.josm.tools.Logging;
    2526import org.openstreetmap.josm.tools.Utils;
     
    9091
    9192            doSave(file, layer);
    92             if ((noBackup || !Main.pref.getBoolean("save.keepbackup", false)) && tmpFile != null) {
     93            if ((noBackup || !Config.getPref().getBoolean("save.keepbackup", false)) && tmpFile != null) {
    9394                Utils.deleteFile(tmpFile);
    9495            }
  • trunk/src/org/openstreetmap/josm/gui/layer/AutosaveTask.java

    r12671 r12846  
    4646import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
    4747import org.openstreetmap.josm.gui.util.GuiHelper;
     48import org.openstreetmap.josm.spi.preferences.Config;
    4849import org.openstreetmap.josm.tools.Logging;
    4950import org.openstreetmap.josm.tools.Utils;
     
    193194            String filename = String.format("%1$s_%2$tY%2$tm%2$td_%2$tH%2$tM%2$tS%2$tL%3$s",
    194195                    layer.layerFileName, now, index == 0 ? "" : ('_' + Integer.toString(index)));
    195             File result = new File(autosaveDir, filename + '.' + Main.pref.get("autosave.extension", "osm"));
     196            File result = new File(autosaveDir, filename + '.' + Config.getPref().get("autosave.extension", "osm"));
    196197            try {
    197198                if (index > PROP_INDEX_LIMIT.get())
  • trunk/src/org/openstreetmap/josm/gui/layer/NoteLayer.java

    r12671 r12846  
    2323import javax.swing.SwingUtilities;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.actions.SaveActionBase;
    2726import org.openstreetmap.josm.data.Bounds;
     
    4342import org.openstreetmap.josm.io.OsmApi;
    4443import org.openstreetmap.josm.io.XmlWriter;
     44import org.openstreetmap.josm.spi.preferences.Config;
    4545import org.openstreetmap.josm.tools.ColorHelper;
    4646import org.openstreetmap.josm.tools.ImageProvider;
     
    165165            Point p = mv.getPoint(noteData.getSelectedNote().getLatLon());
    166166
    167             g.setColor(ColorHelper.html2color(Main.pref.get("color.selected")));
     167            g.setColor(ColorHelper.html2color(Config.getPref().get("color.selected")));
    168168            g.drawRect(p.x - (iconWidth / 2), p.y - iconHeight,
    169169                    iconWidth - 1, iconHeight - 1);
  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r12809 r12846  
    104104import org.openstreetmap.josm.gui.widgets.FileChooserManager;
    105105import org.openstreetmap.josm.gui.widgets.JosmTextArea;
     106import org.openstreetmap.josm.spi.preferences.Config;
    106107import org.openstreetmap.josm.tools.AlphanumComparator;
    107108import org.openstreetmap.josm.tools.CheckParameterUtil;
     
    430431    @Override public void paint(final Graphics2D g, final MapView mv, Bounds box) {
    431432        boolean active = mv.getLayerManager().getActiveLayer() == this;
    432         boolean inactive = !active && Main.pref.getBoolean("draw.data.inactive_color", true);
     433        boolean inactive = !active && Config.getPref().getBoolean("draw.data.inactive_color", true);
    433434        boolean virtual = !inactive && mv.isVirtualNodesEnabled();
    434435
    435436        // draw the hatched area for non-downloaded region. only draw if we're the active
    436437        // and bounds are defined; don't draw for inactive layers or loaded GPX files etc
    437         if (active && Main.pref.getBoolean("draw.data.downloaded_area", true) && !data.getDataSources().isEmpty()) {
     438        if (active && Config.getPref().getBoolean("draw.data.downloaded_area", true) && !data.getDataSources().isEmpty()) {
    438439            // initialize area with current viewport
    439440            Rectangle b = mv.getBounds();
     
    872873            }
    873874            MainApplication.getLayerManager().addLayer(gpxLayer);
    874             if (Main.pref.getBoolean("marker.makeautomarkers", true) && !gpxData.waypoints.isEmpty()) {
     875            if (Config.getPref().getBoolean("marker.makeautomarkers", true) && !gpxData.waypoints.isEmpty()) {
    875876                MainApplication.getLayerManager().addLayer(new MarkerLayer(gpxData, tr("Converted from: {0}", getName()), null, gpxLayer));
    876877            }
     
    10891090        File file = getAssociatedFile();
    10901091        if (file == null && isRenamed()) {
    1091             StringBuilder filename = new StringBuilder(Main.pref.get("lastDirectory")).append('/').append(getName());
     1092            StringBuilder filename = new StringBuilder(Config.getPref().get("lastDirectory")).append('/').append(getName());
    10921093            if (!OsmImporter.FILE_FILTER.acceptName(filename.toString())) {
    10931094                filename.append('.').append(extension);
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java

    r12841 r12846  
    7979import org.openstreetmap.josm.gui.widgets.JosmTextField;
    8080import org.openstreetmap.josm.io.GpxReader;
     81import org.openstreetmap.josm.spi.preferences.Config;
    8182import org.openstreetmap.josm.tools.ExifReader;
    8283import org.openstreetmap.josm.tools.GBC;
     
    172173                break;
    173174            case DONE:
    174                 Main.pref.put("geoimage.timezone", timezone.formatTimezone());
    175                 Main.pref.put("geoimage.delta", delta.formatOffset());
    176                 Main.pref.putBoolean("geoimage.showThumbs", yLayer.useThumbs);
     175                Config.getPref().put("geoimage.timezone", timezone.formatTimezone());
     176                Config.getPref().put("geoimage.delta", delta.formatOffset());
     177                Config.getPref().putBoolean("geoimage.showThumbs", yLayer.useThumbs);
    177178
    178179                yLayer.useThumbs = cbShowThumbs.isSelected();
     
    421422            JosmComboBox<String> cbTimezones = new JosmComboBox<>(vtTimezones.toArray(new String[vtTimezones.size()]));
    422423
    423             String tzId = Main.pref.get("geoimage.timezoneid", "");
     424            String tzId = Config.getPref().get("geoimage.timezoneid", "");
    424425            TimeZone defaultTz;
    425426            if (tzId.isEmpty()) {
     
    529530                String tzValue = selectedTz.substring(pos + 1, selectedTz.length() - 1);
    530531
    531                 Main.pref.put("geoimage.timezoneid", tzId);
     532                Config.getPref().put("geoimage.timezoneid", tzId);
    532533                tfOffset.setText(Offset.milliseconds(delta).formatOffset());
    533534                tfTimezone.setText(tzValue);
     
    584585
    585586        try {
    586             timezone = Timezone.parseTimezone(Optional.ofNullable(Main.pref.get("geoimage.timezone", "0:00")).orElse("0:00"));
     587            timezone = Timezone.parseTimezone(Optional.ofNullable(Config.getPref().get("geoimage.timezone", "0:00")).orElse("0:00"));
    587588        } catch (ParseException e) {
    588589            timezone = Timezone.ZERO;
     
    593594
    594595        try {
    595             delta = Offset.parseOffset(Main.pref.get("geoimage.delta", "0"));
     596            delta = Offset.parseOffset(Config.getPref().get("geoimage.delta", "0"));
    596597        } catch (ParseException e) {
    597598            delta = Offset.ZERO;
     
    627628        labelPosition.setEnabled(cbExifImg.isEnabled() || cbTaggedImg.isEnabled());
    628629
    629         boolean ticked = yLayer.thumbsLoaded || Main.pref.getBoolean("geoimage.showThumbs", false);
     630        boolean ticked = yLayer.thumbsLoaded || Config.getPref().getBoolean("geoimage.showThumbs", false);
    630631        cbShowThumbs = new JCheckBox(tr("Show Thumbnail images on the map"), ticked);
    631632        cbShowThumbs.setEnabled(!yLayer.thumbsLoaded);
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java

    r12620 r12846  
    2626import javax.swing.JComponent;
    2727
    28 import org.openstreetmap.josm.Main;
     28import org.openstreetmap.josm.spi.preferences.Config;
    2929import org.openstreetmap.josm.tools.ExifReader;
    3030import org.openstreetmap.josm.tools.Logging;
     
    5858    private String osdText;
    5959
    60     private static final int DRAG_BUTTON = Main.pref.getBoolean("geoimage.agpifo-style-drag-and-zoom", false) ? 1 : 3;
     60    private static final int DRAG_BUTTON = Config.getPref().getBoolean("geoimage.agpifo-style-drag-and-zoom", false) ? 1 : 3;
    6161    private static final int ZOOM_BUTTON = DRAG_BUTTON == 1 ? 3 : 1;
    6262
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ThumbsLoader.java

    r12630 r12846  
    2222import org.openstreetmap.josm.data.cache.JCSCacheManager;
    2323import org.openstreetmap.josm.gui.MainApplication;
     24import org.openstreetmap.josm.spi.preferences.Config;
    2425import org.openstreetmap.josm.tools.ExifReader;
    2526import org.openstreetmap.josm.tools.Logging;
     
    3839    private MediaTracker tracker;
    3940    private ICacheAccess<String, BufferedImageCacheEntry> cache;
    40     private final boolean cacheOff = Main.pref.getBoolean("geoimage.noThumbnailCache", false);
     41    private final boolean cacheOff = Config.getPref().getBoolean("geoimage.noThumbnailCache", false);
    4142
    4243    private ThumbsLoader(Collection<ImageEntry> data, GeoImageLayer layer) {
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerAction.java

    r12841 r12846  
    3636import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer;
    3737import org.openstreetmap.josm.gui.widgets.UrlLabel;
     38import org.openstreetmap.josm.spi.preferences.Config;
    3839import org.openstreetmap.josm.tools.GBC;
    3940import org.openstreetmap.josm.tools.ImageProvider;
     
    119120            for (Marker marker : layer.data) {
    120121                final Node node = new Node(marker.getCoor());
    121                 final Collection<String> mapping = Main.pref.getList("gpx.to-osm-mapping", Arrays.asList(
     122                final Collection<String> mapping = Config.getPref().getList("gpx.to-osm-mapping", Arrays.asList(
    122123                        GpxConstants.GPX_NAME, "name",
    123124                        GpxConstants.GPX_DESC, "description",
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/DateFilterPanel.java

    r12841 r12846  
    1919import org.openstreetmap.josm.gui.layer.GpxLayer;
    2020import org.openstreetmap.josm.gui.widgets.DateEditorWithSlider;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2122import org.openstreetmap.josm.tools.GBC;
    2223
     
    105106        Main.pref.putLong(prefDateMin, dateFrom.getDate().getTime());
    106107        Main.pref.putLong(prefDateMax, dateTo.getDate().getTime());
    107         Main.pref.putBoolean(prefDate0, noTimestampCb.isSelected());
     108        Config.getPref().putBoolean(prefDate0, noTimestampCb.isSelected());
    108109    }
    109110
     
    117118        long t2 = Main.pref.getLong(prefDateMax, 0);
    118119        if (t2 != 0) dateTo.setDate(new Date(t2));
    119         noTimestampCb.setSelected(Main.pref.getBoolean(prefDate0, false));
     120        noTimestampCb.setSelected(Config.getPref().getBoolean(prefDate0, false));
    120121    }
    121122
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongPanel.java

    r12841 r12846  
    1919import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2020import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2122import org.openstreetmap.josm.tools.GBC;
    2223import org.openstreetmap.josm.tools.ImageProvider;
     
    6061        this.prefNear = prefNear;
    6162
    62         cbDownloadOsmData = new JCheckBox(tr("OpenStreetMap data"), Main.pref.getBoolean(prefOsm, true));
     63        cbDownloadOsmData = new JCheckBox(tr("OpenStreetMap data"), Config.getPref().getBoolean(prefOsm, true));
    6364        cbDownloadOsmData.setToolTipText(tr("Select to download OSM data."));
    6465        add(cbDownloadOsmData, GBC.std().insets(1, 5, 1, 5));
    65         cbDownloadGpxData = new JCheckBox(tr("Raw GPS data"), Main.pref.getBoolean(prefGps, false));
     66        cbDownloadGpxData = new JCheckBox(tr("Raw GPS data"), Config.getPref().getBoolean(prefGps, false));
    6667        cbDownloadGpxData.setToolTipText(tr("Select to download GPS traces."));
    6768        add(cbDownloadGpxData, GBC.eol().insets(5, 5, 1, 5));
     
    8586            add(new JLabel(tr("Download near:")), GBC.eol());
    8687            downloadNear = new JList<>(new String[]{tr("track only"), tr("waypoints only"), tr("track and waypoints")});
    87             downloadNear.setSelectedIndex(Main.pref.getInt(prefNear, 0));
     88            downloadNear.setSelectedIndex(Config.getPref().getInt(prefNear, 0));
    8889            add(downloadNear, GBC.eol());
    8990        } else {
     
    138139     */
    139140    protected final void rememberSettings() {
    140         Main.pref.putBoolean(prefOsm, isDownloadOsmData());
    141         Main.pref.putBoolean(prefGps, isDownloadGpxData());
    142         Main.pref.putDouble(prefDist, getDistance());
    143         Main.pref.putDouble(prefArea, getArea());
     141        Config.getPref().putBoolean(prefOsm, isDownloadOsmData());
     142        Config.getPref().putBoolean(prefGps, isDownloadGpxData());
     143        Config.getPref().putDouble(prefDist, getDistance());
     144        Config.getPref().putDouble(prefArea, getArea());
    144145        if (prefNear != null) {
    145             Main.pref.putInt(prefNear, getNear());
     146            Config.getPref().putInt(prefNear, getNear());
    146147        }
    147148    }
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java

    r12841 r12846  
    5353import org.openstreetmap.josm.gui.layer.MapViewPaintable.PaintableInvalidationListener;
    5454import org.openstreetmap.josm.io.CachedFile;
     55import org.openstreetmap.josm.spi.preferences.Config;
    5556import org.openstreetmap.josm.tools.ColorScale;
    5657import org.openstreetmap.josm.tools.JosmRuntimeException;
     
    183184
    184185    private void setupColors() {
    185         hdopAlpha = Main.pref.getInt("hdop.color.alpha", -1);
     186        hdopAlpha = Config.getPref().getInt("hdop.color.alpha", -1);
    186187        velocityScale = ColorScale.createHSBScale(256);
    187188        /** Colors (without custom alpha channel, if given) for HDOP painting. **/
     
    320321        colorModeDynamic = Main.pref.getBoolean("draw.rawgps.colors.dynamic", spec, false);
    321322        /* good HDOP's are between 1 and 3, very bad HDOP's go into 3 digit values */
    322         hdoprange = Main.pref.getInt("hdop.range", 7);
    323         minTrackDurationForTimeColoring = Main.pref.getInt("draw.rawgps.date-coloring-min-dt", 60);
    324         largePointAlpha = Main.pref.getInt("draw.rawgps.large.alpha", -1) & 0xFF;
     323        hdoprange = Config.getPref().getInt("hdop.range", 7);
     324        minTrackDurationForTimeColoring = Config.getPref().getInt("draw.rawgps.date-coloring-min-dt", 60);
     325        largePointAlpha = Config.getPref().getInt("draw.rawgps.large.alpha", -1) & 0xFF;
    325326
    326327        // get heatmap parameters
     
    428429        // set hints for the render
    429430        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
    430             Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false) ?
     431            Config.getPref().getBoolean("mappaint.gpx.use-antialiasing", false) ?
    431432                    RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
    432433
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java

    r12725 r12846  
    3232import org.openstreetmap.josm.gui.widgets.AbstractFileChooser;
    3333import org.openstreetmap.josm.io.audio.AudioUtil;
     34import org.openstreetmap.josm.spi.preferences.Config;
    3435import org.openstreetmap.josm.tools.ImageProvider;
    3536import org.openstreetmap.josm.tools.Utils;
     
    138139        boolean timedMarkersOmitted = false;
    139140        boolean untimedMarkersOmitted = false;
    140         double snapDistance = Main.pref.getDouble("marker.audiofromuntimedwaypoints.distance", 1.0e-3);
     141        double snapDistance = Config.getPref().getDouble("marker.audiofromuntimedwaypoints.distance", 1.0e-3);
    141142        // about 25 m
    142143        WayPoint wayPointFromTimeStamp = null;
     
    171172
    172173        // (a) try explicit timestamped waypoints - unless suppressed
    173         if (hasWaypoints && Main.pref.getBoolean("marker.audiofromexplicitwaypoints", true)) {
     174        if (hasWaypoints && Config.getPref().getBoolean("marker.audiofromexplicitwaypoints", true)) {
    174175            for (WayPoint w : layer.data.waypoints) {
    175176                if (w.time > firstTime) {
     
    182183
    183184        // (b) try explicit waypoints without timestamps - unless suppressed
    184         if (hasWaypoints && Main.pref.getBoolean("marker.audiofromuntimedwaypoints", true)) {
     185        if (hasWaypoints && Config.getPref().getBoolean("marker.audiofromuntimedwaypoints", true)) {
    185186            for (WayPoint w : layer.data.waypoints) {
    186187                if (waypoints.contains(w)) {
     
    202203
    203204        // (c) use explicitly named track points, again unless suppressed
    204         if (layer.data.tracks != null && Main.pref.getBoolean("marker.audiofromnamedtrackpoints", false)
     205        if (layer.data.tracks != null && Config.getPref().getBoolean("marker.audiofromnamedtrackpoints", false)
    205206                && !layer.data.tracks.isEmpty()) {
    206207            for (GpxTrack track : layer.data.tracks) {
     
    216217
    217218        // (d) use timestamp of file as location on track
    218         if (hasTracks && Main.pref.getBoolean("marker.audiofromwavtimestamps", false)) {
     219        if (hasTracks && Config.getPref().getBoolean("marker.audiofromwavtimestamps", false)) {
    219220            double lastModified = audioFile.lastModified() / 1000.0; // lastModified is in milliseconds
    220221            double duration = AudioUtil.getCalibratedDuration(audioFile);
    221222            double startTime = lastModified - duration;
    222223            startTime = firstStartTime + (startTime - firstStartTime)
    223                     / Main.pref.getDouble("audio.calibration", 1.0 /* default, ratio */);
     224                    / Config.getPref().getDouble("audio.calibration", 1.0 /* default, ratio */);
    224225            WayPoint w1 = null;
    225226            WayPoint w2 = null;
     
    259260
    260261        // (f) simply add a single marker at the start of the track
    261         if ((Main.pref.getBoolean("marker.audiofromstart") || waypoints.isEmpty()) && hasTracks) {
     262        if ((Config.getPref().getBoolean("marker.audiofromstart") || waypoints.isEmpty()) && hasTracks) {
    262263            boolean gotOne = false;
    263264            for (GpxTrack track : layer.data.tracks) {
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportImagesAction.java

    r12671 r12846  
    2121import org.openstreetmap.josm.gui.widgets.AbstractFileChooser;
    2222import org.openstreetmap.josm.gui.widgets.FileChooserManager;
     23import org.openstreetmap.josm.spi.preferences.Config;
    2324import org.openstreetmap.josm.tools.ImageProvider;
    2425import org.openstreetmap.josm.tools.Utils;
     
    6869        }
    6970        JpgImporter importer = new JpgImporter(layer);
    70         AbstractFileChooser fc = new FileChooserManager(true, "geoimage.lastdirectory", Main.pref.get("lastDirectory")).
     71        AbstractFileChooser fc = new FileChooserManager(true, "geoimage.lastdirectory", Config.getPref().get("lastDirectory")).
    7172                createFileChooser(true, null, importer.filter, JFileChooser.FILES_AND_DIRECTORIES).openFileChooser();
    7273        if (fc != null) {
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/ReprojectionTile.java

    r12841 r12846  
    1515import org.openstreetmap.josm.data.projection.Projections;
    1616import org.openstreetmap.josm.gui.MainApplication;
     17import org.openstreetmap.josm.spi.preferences.Config;
    1718import org.openstreetmap.josm.tools.ImageWarp;
    1819import org.openstreetmap.josm.tools.Utils;
     
    113114        double scaleMapView = MainApplication.getMap().mapView.getScale();
    114115        ImageWarp.Interpolation interpolation;
    115         switch (Main.pref.get("imagery.warp.pixel-interpolation", "bilinear")) {
     116        switch (Config.getPref().get("imagery.warp.pixel-interpolation", "bilinear")) {
    116117            case "nearest_neighbor":
    117118                interpolation = ImageWarp.Interpolation.NEAREST_NEIGHBOR;
     
    159160
    160161        ImageWarp.PointTransform transform;
    161         int stride = Main.pref.getInt("imagery.warp.projection-interpolation.stride", 7);
     162        int stride = Config.getPref().getInt("imagery.warp.projection-interpolation.stride", 7);
    162163        if (stride > 0) {
    163164            transform = new ImageWarp.GridTransform(pointTransform, stride);
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/TileSourceDisplaySettings.java

    r12713 r12846  
    1313import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
    1414import org.openstreetmap.josm.io.session.SessionAwareReadApply;
     15import org.openstreetmap.josm.spi.preferences.Config;
    1516import org.openstreetmap.josm.tools.CheckParameterUtil;
    1617import org.openstreetmap.josm.tools.JosmRuntimeException;
     
    101102        for (String p : prefixes) {
    102103            String key = p + "." + name;
    103             boolean currentValue = Main.pref.getBoolean(key, true);
    104             if (!Main.pref.get(key).isEmpty()) {
     104            boolean currentValue = Config.getPref().getBoolean(key, true);
     105            if (!Config.getPref().get(key).isEmpty()) {
    105106                value = currentValue;
    106107            }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/ButtonMarker.java

    r12725 r12846  
    1111import javax.swing.border.Border;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.coor.LatLon;
    1514import org.openstreetmap.josm.gui.MainApplication;
    1615import org.openstreetmap.josm.gui.MapView;
     16import org.openstreetmap.josm.spi.preferences.Config;
    1717import org.openstreetmap.josm.tools.template_engine.TemplateEngineDataProvider;
    1818
     
    6767
    6868        String labelText = getText();
    69         if (labelText != null && Main.pref.getBoolean("marker.buttonlabels", true)) {
     69        if (labelText != null && Config.getPref().getBoolean("marker.buttonlabels", true)) {
    7070            g.drawString(labelText, screen.x+4, screen.y+2);
    7171        }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

    r12725 r12846  
    5151import org.openstreetmap.josm.gui.layer.gpx.ConvertToDataLayerAction;
    5252import org.openstreetmap.josm.io.audio.AudioPlayer;
     53import org.openstreetmap.josm.spi.preferences.Config;
    5354import org.openstreetmap.josm.tools.ImageProvider;
    5455import org.openstreetmap.josm.tools.Logging;
     
    230231        components.add(SeparatorLayerAction.INSTANCE);
    231232        components.add(new SynchronizeAudio());
    232         if (Main.pref.getBoolean("marker.traceaudio", true)) {
     233        if (Config.getPref().getBoolean("marker.traceaudio", true)) {
    233234            components.add(new MoveAudio());
    234235        }
     
    439440     */
    440441    private boolean isTextOrIconShown() {
    441         String current = Main.pref.get("marker.show "+getName(), "show");
     442        String current = Config.getPref().get("marker.show "+getName(), "show");
    442443        return "show".equalsIgnoreCase(current);
    443444    }
     
    491492        @Override
    492493        public void actionPerformed(ActionEvent e) {
    493             Main.pref.put("marker.show "+layer.getName(), layer.isTextOrIconShown() ? "hide" : "show");
     494            Config.getPref().put("marker.show "+layer.getName(), layer.isTextOrIconShown() ? "hide" : "show");
    494495            layer.invalidate();
    495496        }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java

    r12841 r12846  
    2828import org.openstreetmap.josm.io.audio.AudioPlayer;
    2929import org.openstreetmap.josm.io.audio.AudioUtil;
     30import org.openstreetmap.josm.spi.preferences.Config;
    3031
    3132/**
     
    6061    private PlayHeadMarker() {
    6162        super(LatLon.ZERO, "",
    62                 Main.pref.get("marker.audiotracericon", "audio-tracer"),
     63                Config.getPref().get("marker.audiotracericon", "audio-tracer"),
    6364                null, -1.0, 0.0);
    64         enabled = Main.pref.getBoolean("marker.traceaudio", true);
     65        enabled = Config.getPref().getBoolean("marker.traceaudio", true);
    6566        if (!enabled) return;
    66         dropTolerance = Main.pref.getInt("marker.playHeadDropTolerance", 50);
     67        dropTolerance = Config.getPref().getInt("marker.playHeadDropTolerance", 50);
    6768        if (MainApplication.isDisplayingMapView()) {
    6869            MapFrame map = MainApplication.getMap();
     
    294295        jumpToMarker = true;
    295296        if (timer == null) {
    296             animationInterval = Main.pref.getDouble("marker.audioanimationinterval", 1.0); //milliseconds
     297            animationInterval = Config.getPref().getDouble("marker.audioanimationinterval", 1.0); //milliseconds
    297298            timer = new Timer((int) (animationInterval * 1000.0), e -> timerAction());
    298299            timer.setInitialDelay(0);
  • trunk/src/org/openstreetmap/josm/gui/mappaint/ElemStyles.java

    r12700 r12846  
    1111import java.util.Map.Entry;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
    1514import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
     
    3332import org.openstreetmap.josm.gui.mappaint.styleelement.TextLabel;
    3433import org.openstreetmap.josm.gui.util.GuiHelper;
     34import org.openstreetmap.josm.spi.preferences.Config;
    3535import org.openstreetmap.josm.tools.Pair;
    3636import org.openstreetmap.josm.tools.Utils;
     
    7474    public ElemStyles() {
    7575        styleSources = new ArrayList<>();
    76         Main.pref.addPreferenceChangeListener(this);
     76        Config.getPref().addPreferenceChangeListener(this);
    7777    }
    7878
     
    517517     * Determines whether primitive has area-type {@link StyleElement}s, but
    518518     * no line-type StyleElements.
    519      * 
     519     *
    520520     * {@link TextElement} is ignored, as it can be both line and area-type.
    521521     * @param p the OSM primitive
     
    551551     *
    552552     * In addition, it adds an intermediate cache for the preference values,
    553      * as frequent preference lookup (using <code>Main.pref.get()</code>) for
     553     * as frequent preference lookup (using <code>Config.getPref().get()</code>) for
    554554     * each primitive can be slow during rendering.
    555555     *
     
    564564            res = preferenceCache.get(key);
    565565        } else {
    566             res = Main.pref.get(key, null);
     566            res = Config.getPref().get(key, null);
    567567            preferenceCache.put(key, res);
    568568        }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/MapPaintStyles.java

    r12841 r12846  
    2727import org.openstreetmap.josm.gui.mappaint.styleelement.StyleElement;
    2828import org.openstreetmap.josm.io.CachedFile;
     29import org.openstreetmap.josm.spi.preferences.Config;
    2930import org.openstreetmap.josm.tools.ImageProvider;
    3031import org.openstreetmap.josm.tools.ListenerList;
     
    256257        }
    257258
    258         Collection<String> prefIconDirs = Main.pref.getList("mappaint.icon.sources");
     259        Collection<String> prefIconDirs = Config.getPref().getList("mappaint.icon.sources");
    259260        for (String fileset : prefIconDirs) {
    260261            String[] a;
     
    271272        }
    272273
    273         if (Main.pref.getBoolean("mappaint.icon.enable-defaults", true)) {
     274        if (Config.getPref().getBoolean("mappaint.icon.enable-defaults", true)) {
    274275            /* don't prefix icon path, as it should be generic */
    275276            dirs.add("resource://images/");
     
    299300        final long startTime = System.currentTimeMillis();
    300301        source.loadStyleSource();
    301         if (Main.pref.getBoolean("mappaint.auto_reload_local_styles", true) && source.isLocal()) {
     302        if (Config.getPref().getBoolean("mappaint.auto_reload_local_styles", true) && source.isLocal()) {
    302303            try {
    303304                Main.fileWatcher.registerSource(source);
  • trunk/src/org/openstreetmap/josm/gui/mappaint/StyleSetting.java

    r12841 r12846  
    22package org.openstreetmap.josm.gui.mappaint;
    33
    4 import org.openstreetmap.josm.Main;
     4import org.openstreetmap.josm.spi.preferences.Config;
    55import org.openstreetmap.josm.tools.Logging;
    66
     
    6666        @Override
    6767        public Object getValue() {
    68             String val = Main.pref.get(prefKey, null);
     68            String val = Config.getPref().get(prefKey, null);
    6969            if (val == null) return def;
    7070            return Boolean.valueOf(val);
     
    7777            boolean b = (Boolean) o;
    7878            if (b == def) {
    79                 Main.pref.put(prefKey, null);
     79                Config.getPref().put(prefKey, null);
    8080            } else {
    81                 Main.pref.putBoolean(prefKey, b);
     81                Config.getPref().putBoolean(prefKey, b);
    8282            }
    8383        }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

    r12756 r12846  
    2828import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2929import org.openstreetmap.josm.data.osm.Way;
    30 import org.openstreetmap.josm.data.osm.search.SearchParseError;
    3130import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    3231import org.openstreetmap.josm.data.osm.search.SearchCompiler.Match;
     32import org.openstreetmap.josm.data.osm.search.SearchParseError;
    3333import org.openstreetmap.josm.gui.mappaint.Cascade;
    3434import org.openstreetmap.josm.gui.mappaint.Environment;
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSStyleSource.java

    r12649 r12846  
    3232import org.openstreetmap.josm.data.osm.AbstractPrimitive;
    3333import org.openstreetmap.josm.data.osm.AbstractPrimitive.KeyValueVisitor;
    34 import org.openstreetmap.josm.data.preferences.sources.SourceEntry;
    3534import org.openstreetmap.josm.data.osm.Node;
    3635import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3736import org.openstreetmap.josm.data.osm.Relation;
    3837import org.openstreetmap.josm.data.osm.Way;
     38import org.openstreetmap.josm.data.preferences.sources.SourceEntry;
    3939import org.openstreetmap.josm.gui.mappaint.Cascade;
    4040import org.openstreetmap.josm.gui.mappaint.Environment;
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/AreaElement.java

    r12841 r12846  
    77import java.util.Objects;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1110import org.openstreetmap.josm.data.osm.Relation;
     
    1716import org.openstreetmap.josm.gui.mappaint.Environment;
    1817import org.openstreetmap.josm.gui.mappaint.MapPaintStyles.IconReference;
     18import org.openstreetmap.josm.spi.preferences.Config;
    1919import org.openstreetmap.josm.tools.CheckParameterUtil;
    2020import org.openstreetmap.josm.tools.HiDPISupport;
     
    9090            );
    9191
    92             fillImage.alpha = Utils.clamp(Main.pref.getInt("mappaint.fill-image-alpha", 255), 0, 255);
     92            fillImage.alpha = Utils.clamp(Config.getPref().getInt("mappaint.fill-image-alpha", 255), 0, 255);
    9393            Integer pAlpha = Utils.colorFloat2int(c.get(FILL_OPACITY, null, float.class));
    9494            if (pAlpha != null) {
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/LabelCompositionStrategy.java

    r12841 r12846  
    1212import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    1313import org.openstreetmap.josm.data.osm.OsmPrimitive;
     14import org.openstreetmap.josm.spi.preferences.Config;
    1415import org.openstreetmap.josm.tools.LanguageInfo;
    1516
     
    233234         */
    234235        public final void initNameTagsFromPreferences() {
    235             if (Main.pref == null) {
     236            if (Config.getPref() == null) {
    236237                this.nameTags = new ArrayList<>(Arrays.asList(DEFAULT_NAME_TAGS));
    237238                this.nameComplementTags = new ArrayList<>(Arrays.asList(DEFAULT_NAME_COMPLEMENT_TAGS));
    238239            } else {
    239240                this.nameTags = new ArrayList<>(
    240                         Main.pref.getList("mappaint.nameOrder", Arrays.asList(DEFAULT_NAME_TAGS))
     241                        Config.getPref().getList("mappaint.nameOrder", Arrays.asList(DEFAULT_NAME_TAGS))
    241242                );
    242243                this.nameComplementTags = new ArrayList<>(
    243                         Main.pref.getList("mappaint.nameComplementOrder", Arrays.asList(DEFAULT_NAME_COMPLEMENT_TAGS))
     244                        Config.getPref().getList("mappaint.nameComplementOrder", Arrays.asList(DEFAULT_NAME_COMPLEMENT_TAGS))
    244245                );
    245246            }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/NodeElement.java

    r12841 r12846  
    1010import java.util.stream.IntStream;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.osm.Node;
    1413import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2524import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.BoxProvider;
    2625import org.openstreetmap.josm.gui.mappaint.styleelement.BoxTextElement.SimpleBoxProvider;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2727import org.openstreetmap.josm.tools.CheckParameterUtil;
    2828import org.openstreetmap.josm.tools.Logging;
     
    196196        mapImage.offsetY = Math.round(offsetYF);
    197197
    198         mapImage.alpha = Utils.clamp(Main.pref.getInt("mappaint.icon-image-alpha", 255), 0, 255);
     198        mapImage.alpha = Utils.clamp(Config.getPref().getInt("mappaint.icon-image-alpha", 255), 0, 255);
    199199        Integer pAlpha = Utils.colorFloat2int(c.get(keys[ICON_OPACITY_IDX], null, float.class));
    200200        if (pAlpha != null) {
     
    356356            // This is only executed once, so no performance concerns.
    357357            // However, it would be better, if the settings could be changed at runtime.
    358             int size = max(
    359                     Main.pref.getInt("mappaint.node.selected-size", 5),
    360                     Main.pref.getInt("mappaint.node.unselected-size", 3),
    361                     Main.pref.getInt("mappaint.node.connection-size", 5),
    362                     Main.pref.getInt("mappaint.node.tagged-size", 3)
     358            int size = max(Config.getPref().getInt("mappaint.node.selected-size", 5),
     359                    Config.getPref().getInt("mappaint.node.unselected-size", 3),
     360                    Config.getPref().getInt("mappaint.node.connection-size", 5),
     361                    Config.getPref().getInt("mappaint.node.tagged-size", 3)
    363362            );
    364363            return new SimpleBoxProvider(new Rectangle(-size/2, -size/2, size, size));
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/StyleElement.java

    r12841 r12846  
    77import java.util.Objects;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1110import org.openstreetmap.josm.data.osm.visitor.paint.MapPaintSettings;
     
    1514import org.openstreetmap.josm.gui.mappaint.StyleKeys;
    1615import org.openstreetmap.josm.gui.mappaint.mapcss.Instruction.RelativeFloat;
     16import org.openstreetmap.josm.spi.preferences.Config;
    1717
    1818/**
     
    148148                s = defaultFontSize;
    149149                if (s == null) {
    150                     defaultFontSize = s = (float) Main.pref.getInt("mappaint.fontsize", 8);
     150                    defaultFontSize = s = (float) Config.getPref().getInt("mappaint.fontsize", 8);
    151151                }
    152152            }
     
    161161                n = defaultFontName;
    162162                if (n == null) {
    163                     defaultFontName = n = Main.pref.get("mappaint.font", "Droid Sans");
     163                    defaultFontName = n = Config.getPref().get("mappaint.font", "Droid Sans");
    164164                }
    165165            }
  • trunk/src/org/openstreetmap/josm/gui/preferences/SourceEditor.java

    r12841 r12846  
    9393import org.openstreetmap.josm.io.OnlineResource;
    9494import org.openstreetmap.josm.io.OsmTransferException;
     95import org.openstreetmap.josm.spi.preferences.Config;
    9596import org.openstreetmap.josm.tools.GBC;
    9697import org.openstreetmap.josm.tools.ImageOverlay;
     
    423424
    424425            if (!iconPaths.isEmpty()) {
    425                 if (Main.pref.putList(iconPref, iconPaths)) {
     426                if (Config.getPref().putList(iconPref, iconPaths)) {
    426427                    changed = true;
    427428                }
    428             } else if (Main.pref.putList(iconPref, null)) {
     429            } else if (Config.getPref().putList(iconPref, null)) {
    429430                changed = true;
    430431            }
  • trunk/src/org/openstreetmap/josm/gui/preferences/ToolbarPreferences.java

    r12841 r12846  
    7171import org.openstreetmap.josm.gui.tagging.presets.TaggingPreset;
    7272import org.openstreetmap.josm.gui.util.GuiHelper;
     73import org.openstreetmap.josm.spi.preferences.Config;
    7374import org.openstreetmap.josm.tools.GBC;
    7475import org.openstreetmap.josm.tools.ImageProvider;
     
    488489        private void setActionAndAdapt(ActionDefinition action) {
    489490            this.act = action;
    490             doNotHide.setSelected(Main.pref.getBoolean("toolbar.always-visible", true));
     491            doNotHide.setSelected(Config.getPref().getBoolean("toolbar.always-visible", true));
    491492            remove.setVisible(act != null);
    492493            shortcutEdit.setVisible(act != null);
     
    502503                // remove the button from toolbar preferences
    503504                t.remove(res);
    504                 Main.pref.putList("toolbar", t);
     505                Config.getPref().putList("toolbar", t);
    505506                MainApplication.getToolbar().refreshToolbarControl();
    506507            }
     
    532533            public void actionPerformed(ActionEvent e) {
    533534                boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
    534                 Main.pref.putBoolean("toolbar.always-visible", sel);
    535                 Main.pref.putBoolean("menu.always-visible", sel);
     535                Config.getPref().putBoolean("toolbar.always-visible", sel);
     536                Config.getPref().putBoolean("menu.always-visible", sel);
    536537            }
    537538        });
     
    987988                t = Collections.singletonList(EMPTY_TOOLBAR_MARKER);
    988989            }
    989             Main.pref.putList("toolbar", t);
     990            Config.getPref().putList("toolbar", t);
    990991            MainApplication.getToolbar().refreshToolbarControl();
    991992            return false;
     
    10021003            control.setComponentPopupMenu(popupMenu);
    10031004        });
    1004         Main.pref.addPreferenceChangeListener(e -> {
     1005        Config.getPref().addPreferenceChangeListener(e -> {
    10051006            if ("toolbar.visible".equals(e.getKey())) {
    10061007                refreshToolbarControl();
     
    10741075    public static Collection<String> getToolString() {
    10751076
    1076         Collection<String> toolStr = Main.pref.getList("toolbar", Arrays.asList(deftoolbar));
     1077        Collection<String> toolStr = Config.getPref().getList("toolbar", Arrays.asList(deftoolbar));
    10771078        if (toolStr == null || toolStr.isEmpty()) {
    10781079            toolStr = Arrays.asList(deftoolbar);
     
    11881189        }
    11891190
    1190         boolean visible = Main.pref.getBoolean("toolbar.visible", true);
     1191        boolean visible = Config.getPref().getBoolean("toolbar.visible", true);
    11911192
    11921193        control.setFocusTraversalKeysEnabled(!unregisterTab);
     
    12141215            }
    12151216        }
    1216         Main.pref.putList("toolbar", t);
     1217        Config.getPref().putList("toolbar", t);
    12171218        MainApplication.getToolbar().refreshToolbarControl();
    12181219    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/audio/AudioPreference.java

    r12841 r12846  
    1111import javax.swing.JPanel;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.gui.preferences.DefaultTabPreferenceSetting;
    1514import org.openstreetmap.josm.gui.preferences.PreferenceSetting;
     
    1817import org.openstreetmap.josm.gui.widgets.JosmTextField;
    1918import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
     19import org.openstreetmap.josm.spi.preferences.Config;
    2020import org.openstreetmap.josm.tools.GBC;
    2121
     
    6060
    6161        // audioMenuVisible
    62         audioMenuVisible.setSelected(!Main.pref.getBoolean("audio.menuinvisible"));
     62        audioMenuVisible.setSelected(!Config.getPref().getBoolean("audio.menuinvisible"));
    6363        audioMenuVisible.setToolTipText(tr("Show or hide the audio menu entry on the main menu bar."));
    6464        audio.add(audioMenuVisible, GBC.eol().insets(0, 0, 0, 0));
    6565
    6666        // audioTraceVisible
    67         markerAudioTraceVisible.setSelected(Main.pref.getBoolean("marker.traceaudio", true));
     67        markerAudioTraceVisible.setSelected(Config.getPref().getBoolean("marker.traceaudio", true));
    6868        markerAudioTraceVisible.setToolTipText(
    6969                tr("Display a moving icon representing the point on the synchronized track where the audio currently playing was recorded."));
     
    7171
    7272        // buttonLabels
    73         markerButtonLabels.setSelected(Main.pref.getBoolean("marker.buttonlabels", true));
     73        markerButtonLabels.setSelected(Config.getPref().getBoolean("marker.buttonlabels", true));
    7474        markerButtonLabels.setToolTipText(tr("Put text labels against audio (and image and web) markers as well as their button icons."));
    7575        audio.add(markerButtonLabels, GBC.eol().insets(0, 0, 0, 0));
     
    7878
    7979        // audioMarkersFromExplicitWaypoints
    80         audioMarkersFromExplicitWaypoints.setSelected(Main.pref.getBoolean("marker.audiofromexplicitwaypoints", true));
     80        audioMarkersFromExplicitWaypoints.setSelected(Config.getPref().getBoolean("marker.audiofromexplicitwaypoints", true));
    8181        audioMarkersFromExplicitWaypoints.setToolTipText(tr("When importing audio, apply it to any waypoints in the GPX layer."));
    8282        audio.add(audioMarkersFromExplicitWaypoints, GBC.eol().insets(10, 0, 0, 0));
    8383
    8484        // audioMarkersFromUntimedWaypoints
    85         audioMarkersFromUntimedWaypoints.setSelected(Main.pref.getBoolean("marker.audiofromuntimedwaypoints", true));
     85        audioMarkersFromUntimedWaypoints.setSelected(Config.getPref().getBoolean("marker.audiofromuntimedwaypoints", true));
    8686        audioMarkersFromUntimedWaypoints.setToolTipText(tr("When importing audio, apply it to any waypoints in the GPX layer."));
    8787        audio.add(audioMarkersFromUntimedWaypoints, GBC.eol().insets(10, 0, 0, 0));
    8888
    8989        // audioMarkersFromNamedTrackpoints
    90         audioMarkersFromNamedTrackpoints.setSelected(Main.pref.getBoolean("marker.audiofromnamedtrackpoints", false));
     90        audioMarkersFromNamedTrackpoints.setSelected(Config.getPref().getBoolean("marker.audiofromnamedtrackpoints", false));
    9191        audioMarkersFromNamedTrackpoints.setToolTipText(
    9292                tr("Automatically create audio markers from trackpoints (rather than explicit waypoints) with names or descriptions."));
     
    9494
    9595        // audioMarkersFromWavTimestamps
    96         audioMarkersFromWavTimestamps.setSelected(Main.pref.getBoolean("marker.audiofromwavtimestamps", false));
     96        audioMarkersFromWavTimestamps.setSelected(Config.getPref().getBoolean("marker.audiofromwavtimestamps", false));
    9797        audioMarkersFromWavTimestamps.setToolTipText(
    9898                tr("Create audio markers at the position on the track corresponding to the modified time of each audio WAV file imported."));
     
    100100
    101101        // audioMarkersFromStart
    102         audioMarkersFromStart.setSelected(Main.pref.getBoolean("marker.audiofromstart"));
     102        audioMarkersFromStart.setSelected(Config.getPref().getBoolean("marker.audiofromstart"));
    103103        audioMarkersFromStart.setToolTipText(
    104104                tr("Automatically create audio markers from trackpoints (rather than explicit waypoints) with names or descriptions."));
    105105        audio.add(audioMarkersFromStart, GBC.eol().insets(10, 0, 0, 0));
    106106
    107         audioForwardBackAmount.setText(Main.pref.get("audio.forwardbackamount", "10.0"));
     107        audioForwardBackAmount.setText(Config.getPref().get("audio.forwardbackamount", "10.0"));
    108108        audioForwardBackAmount.setToolTipText(tr("The number of seconds to jump forward or back when the relevant button is pressed"));
    109109        audio.add(new JLabel(tr("Forward/back time (seconds)")), GBC.std());
    110110        audio.add(audioForwardBackAmount, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5));
    111111
    112         audioFastForwardMultiplier.setText(Main.pref.get("audio.fastfwdmultiplier", "1.3"));
     112        audioFastForwardMultiplier.setText(Config.getPref().get("audio.fastfwdmultiplier", "1.3"));
    113113        audioFastForwardMultiplier.setToolTipText(tr("The amount by which the speed is multiplied for fast forwarding"));
    114114        audio.add(new JLabel(tr("Fast forward multiplier")), GBC.std());
    115115        audio.add(audioFastForwardMultiplier, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5));
    116116
    117         audioLeadIn.setText(Main.pref.get("audio.leadin", "1.0"));
     117        audioLeadIn.setText(Config.getPref().get("audio.leadin", "1.0"));
    118118        audioLeadIn.setToolTipText(
    119119                tr("Playback starts this number of seconds before (or after, if negative) the audio track position requested"));
     
    121121        audio.add(audioLeadIn, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5));
    122122
    123         audioCalibration.setText(Main.pref.get("audio.calibration", "1.0"));
     123        audioCalibration.setText(Config.getPref().get("audio.calibration", "1.0"));
    124124        audioCalibration.setToolTipText(tr("The ratio of voice recorder elapsed time to true elapsed time"));
    125125        audio.add(new JLabel(tr("Voice recorder calibration")), GBC.std());
     
    133133    @Override
    134134    public boolean ok() {
    135         Main.pref.putBoolean("audio.menuinvisible", !audioMenuVisible.isSelected());
    136         Main.pref.putBoolean("marker.traceaudio", markerAudioTraceVisible.isSelected());
    137         Main.pref.putBoolean("marker.buttonlabels", markerButtonLabels.isSelected());
    138         Main.pref.putBoolean("marker.audiofromexplicitwaypoints", audioMarkersFromExplicitWaypoints.isSelected());
    139         Main.pref.putBoolean("marker.audiofromuntimedwaypoints", audioMarkersFromUntimedWaypoints.isSelected());
    140         Main.pref.putBoolean("marker.audiofromnamedtrackpoints", audioMarkersFromNamedTrackpoints.isSelected());
    141         Main.pref.putBoolean("marker.audiofromwavtimestamps", audioMarkersFromWavTimestamps.isSelected());
    142         Main.pref.putBoolean("marker.audiofromstart", audioMarkersFromStart.isSelected());
    143         Main.pref.put("audio.forwardbackamount", audioForwardBackAmount.getText());
    144         Main.pref.put("audio.fastfwdmultiplier", audioFastForwardMultiplier.getText());
    145         Main.pref.put("audio.leadin", audioLeadIn.getText());
    146         Main.pref.put("audio.calibration", audioCalibration.getText());
     135        Config.getPref().putBoolean("audio.menuinvisible", !audioMenuVisible.isSelected());
     136        Config.getPref().putBoolean("marker.traceaudio", markerAudioTraceVisible.isSelected());
     137        Config.getPref().putBoolean("marker.buttonlabels", markerButtonLabels.isSelected());
     138        Config.getPref().putBoolean("marker.audiofromexplicitwaypoints", audioMarkersFromExplicitWaypoints.isSelected());
     139        Config.getPref().putBoolean("marker.audiofromuntimedwaypoints", audioMarkersFromUntimedWaypoints.isSelected());
     140        Config.getPref().putBoolean("marker.audiofromnamedtrackpoints", audioMarkersFromNamedTrackpoints.isSelected());
     141        Config.getPref().putBoolean("marker.audiofromwavtimestamps", audioMarkersFromWavTimestamps.isSelected());
     142        Config.getPref().putBoolean("marker.audiofromstart", audioMarkersFromStart.isSelected());
     143        Config.getPref().put("audio.forwardbackamount", audioForwardBackAmount.getText());
     144        Config.getPref().put("audio.fastfwdmultiplier", audioFastForwardMultiplier.getText());
     145        Config.getPref().put("audio.leadin", audioLeadIn.getText());
     146        Config.getPref().put("audio.calibration", audioCalibration.getText());
    147147        return false;
    148148    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java

    r12620 r12846  
    4646import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
    4747import org.openstreetmap.josm.gui.util.GuiHelper;
     48import org.openstreetmap.josm.spi.preferences.Config;
    4849import org.openstreetmap.josm.tools.ColorHelper;
    4950import org.openstreetmap.josm.tools.GBC;
     
    272273        boolean ret = false;
    273274        for (String d : del) {
    274             Main.pref.put("color."+d, null);
     275            Config.getPref().put("color."+d, null);
    275276        }
    276277        for (int i = 0; i < colors.getRowCount(); ++i) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/DrawingPreference.java

    r12841 r12846  
    1313import javax.swing.JScrollPane;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.actions.ExpertToggleAction;
    1716import org.openstreetmap.josm.gui.autofilter.AutoFilterManager;
     
    2423import org.openstreetmap.josm.gui.util.GuiHelper;
    2524import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     25import org.openstreetmap.josm.spi.preferences.Config;
    2626import org.openstreetmap.josm.tools.GBC;
    2727
     
    7979        directionHint.addActionListener(e -> {
    8080            if (directionHint.isSelected()) {
    81                 headArrow.setSelected(Main.pref.getBoolean("draw.segment.head_only", false));
     81                headArrow.setSelected(Config.getPref().getBoolean("draw.segment.head_only", false));
    8282            } else {
    8383                headArrow.setSelected(false);
     
    8686        });
    8787        directionHint.setToolTipText(tr("Draw direction hints for way segments."));
    88         directionHint.setSelected(Main.pref.getBoolean("draw.segment.direction", false));
     88        directionHint.setSelected(Config.getPref().getBoolean("draw.segment.direction", false));
    8989
    9090        // only on the head of a way
    9191        headArrow.setToolTipText(tr("Only on the head of a way."));
    92         headArrow.setSelected(Main.pref.getBoolean("draw.segment.head_only", false));
     92        headArrow.setSelected(Config.getPref().getBoolean("draw.segment.head_only", false));
    9393        headArrow.setEnabled(directionHint.isSelected());
    9494
    9595        // draw oneway arrows
    9696        onewayArrow.setToolTipText(tr("Draw arrows in the direction of oneways and other directed features."));
    97         onewayArrow.setSelected(Main.pref.getBoolean("draw.oneway", true));
     97        onewayArrow.setSelected(Config.getPref().getBoolean("draw.oneway", true));
    9898
    9999        // segment order number
    100100        segmentOrderNumber.setToolTipText(tr("Draw the order numbers of all segments within their way."));
    101         segmentOrderNumber.setSelected(Main.pref.getBoolean("draw.segment.order_number", false));
     101        segmentOrderNumber.setSelected(Config.getPref().getBoolean("draw.segment.order_number", false));
    102102        segmentOrderNumberOnSelectedWay.setToolTipText(tr("Draw the order numbers of all segments within their way."));
    103         segmentOrderNumberOnSelectedWay.setSelected(Main.pref.getBoolean("draw.segment.order_number.on_selected", false));
     103        segmentOrderNumberOnSelectedWay.setSelected(Config.getPref().getBoolean("draw.segment.order_number.on_selected", false));
    104104
    105105        // downloaded area
    106106        sourceBounds.setToolTipText(tr("Draw the boundaries of data loaded from the server."));
    107         sourceBounds.setSelected(Main.pref.getBoolean("draw.data.downloaded_area", true));
     107        sourceBounds.setSelected(Config.getPref().getBoolean("draw.data.downloaded_area", true));
    108108
    109109        // virtual nodes
    110110        virtualNodes.setToolTipText(tr("Draw virtual nodes in select mode for easy way modification."));
    111         virtualNodes.setSelected(Main.pref.getInt("mappaint.node.virtual-size", 8) != 0);
     111        virtualNodes.setSelected(Config.getPref().getInt("mappaint.node.virtual-size", 8) != 0);
    112112
    113113        // background layers in inactive color
    114114        inactive.setToolTipText(tr("Draw the inactive data layers in a different color."));
    115         inactive.setSelected(Main.pref.getBoolean("draw.data.inactive_color", true));
     115        inactive.setSelected(Config.getPref().getBoolean("draw.data.inactive_color", true));
    116116
    117117        // antialiasing
    118118        useAntialiasing.setToolTipText(tr("Apply antialiasing to the map view resulting in a smoother appearance."));
    119         useAntialiasing.setSelected(Main.pref.getBoolean("mappaint.use-antialiasing", true));
     119        useAntialiasing.setSelected(Config.getPref().getBoolean("mappaint.use-antialiasing", true));
    120120
    121121        // wireframe mode antialiasing
    122122        useWireframeAntialiasing.setToolTipText(tr("Apply antialiasing to the map view in wireframe mode resulting in a smoother appearance."));
    123         useWireframeAntialiasing.setSelected(Main.pref.getBoolean("mappaint.wireframe.use-antialiasing", false));
     123        useWireframeAntialiasing.setSelected(Config.getPref().getBoolean("mappaint.wireframe.use-antialiasing", false));
    124124
    125125        // highlighting
    126126        useHighlighting.setToolTipText(tr("Hightlight target nodes and ways while drawing or selecting"));
    127         useHighlighting.setSelected(Main.pref.getBoolean("draw.target-highlight", true));
     127        useHighlighting.setSelected(Config.getPref().getBoolean("draw.target-highlight", true));
    128128
    129129        drawHelperLine.setToolTipText(tr("Draw rubber-band helper line"));
    130         drawHelperLine.setSelected(Main.pref.getBoolean("draw.helper-line", true));
     130        drawHelperLine.setSelected(Config.getPref().getBoolean("draw.helper-line", true));
    131131
    132132        // outlineOnly
    133133        outlineOnly.setToolTipText(tr("This option suppresses the filling of areas, overriding anything specified in the selected style."));
    134         outlineOnly.setSelected(Main.pref.getBoolean("draw.data.area_outline_only", false));
     134        outlineOnly.setSelected(Config.getPref().getBoolean("draw.data.area_outline_only", false));
    135135
    136136        // discardable keys
    137137        discardableKeys.setToolTipText(tr("Display keys which have been deemed uninteresting to the point that they can be silently removed."));
    138         discardableKeys.setSelected(Main.pref.getBoolean("display.discardable-keys", false));
     138        discardableKeys.setSelected(Config.getPref().getBoolean("display.discardable-keys", false));
    139139
    140140        // auto filters
     
    195195    public boolean ok() {
    196196        boolean restart = gpxPanel.savePreferences();
    197         Main.pref.putBoolean("draw.data.area_outline_only", outlineOnly.isSelected());
    198         Main.pref.putBoolean("draw.segment.direction", directionHint.isSelected());
    199         Main.pref.putBoolean("draw.segment.head_only", headArrow.isSelected());
    200         Main.pref.putBoolean("draw.oneway", onewayArrow.isSelected());
    201         Main.pref.putBoolean("draw.segment.order_number", segmentOrderNumber.isSelected());
    202         Main.pref.putBoolean("draw.segment.order_number.on_selected", segmentOrderNumberOnSelectedWay.isSelected());
    203         Main.pref.putBoolean("draw.data.downloaded_area", sourceBounds.isSelected());
    204         Main.pref.putBoolean("draw.data.inactive_color", inactive.isSelected());
    205         Main.pref.putBoolean("mappaint.use-antialiasing", useAntialiasing.isSelected());
    206         Main.pref.putBoolean("mappaint.wireframe.use-antialiasing", useWireframeAntialiasing.isSelected());
    207         Main.pref.putBoolean("draw.target-highlight", useHighlighting.isSelected());
    208         Main.pref.putBoolean("draw.helper-line", drawHelperLine.isSelected());
    209         Main.pref.putBoolean("display.discardable-keys", discardableKeys.isSelected());
     197        Config.getPref().putBoolean("draw.data.area_outline_only", outlineOnly.isSelected());
     198        Config.getPref().putBoolean("draw.segment.direction", directionHint.isSelected());
     199        Config.getPref().putBoolean("draw.segment.head_only", headArrow.isSelected());
     200        Config.getPref().putBoolean("draw.oneway", onewayArrow.isSelected());
     201        Config.getPref().putBoolean("draw.segment.order_number", segmentOrderNumber.isSelected());
     202        Config.getPref().putBoolean("draw.segment.order_number.on_selected", segmentOrderNumberOnSelectedWay.isSelected());
     203        Config.getPref().putBoolean("draw.data.downloaded_area", sourceBounds.isSelected());
     204        Config.getPref().putBoolean("draw.data.inactive_color", inactive.isSelected());
     205        Config.getPref().putBoolean("mappaint.use-antialiasing", useAntialiasing.isSelected());
     206        Config.getPref().putBoolean("mappaint.wireframe.use-antialiasing", useWireframeAntialiasing.isSelected());
     207        Config.getPref().putBoolean("draw.target-highlight", useHighlighting.isSelected());
     208        Config.getPref().putBoolean("draw.helper-line", drawHelperLine.isSelected());
     209        Config.getPref().putBoolean("display.discardable-keys", discardableKeys.isSelected());
    210210        AutoFilterManager.PROP_AUTO_FILTER_ENABLED.put(autoFilters.isSelected());
    211211        AutoFilterManager.PROP_AUTO_FILTER_RULE.put(((AutoFilterRule) autoFilterRules.getSelectedItem()).getKey());
    212         int vn = Main.pref.getInt("mappaint.node.virtual-size", 8);
     212        int vn = Config.getPref().getInt("mappaint.node.virtual-size", 8);
    213213        if (virtualNodes.isSelected()) {
    214214            if (vn < 1) {
     
    218218            vn = 0;
    219219        }
    220         Main.pref.putInt("mappaint.node.virtual-size", vn);
     220        Config.getPref().putInt("mappaint.node.virtual-size", vn);
    221221        return restart;
    222222    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java

    r12844 r12846  
    3131import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    3232import org.openstreetmap.josm.gui.widgets.JosmTextField;
     33import org.openstreetmap.josm.spi.preferences.Config;
    3334import org.openstreetmap.josm.tools.GBC;
    3435import org.openstreetmap.josm.tools.Logging;
     
    385386     */
    386387    public final void loadPreferences() {
    387         makeAutoMarkers.setSelected(Main.pref.getBoolean("marker.makeautomarkers", true));
    388         if (layerName != null && Main.pref.get("draw.rawgps.lines."+layerName).isEmpty()
    389                 && Main.pref.get("draw.rawgps.lines.local."+layerName).isEmpty()) {
     388        makeAutoMarkers.setSelected(Config.getPref().getBoolean("marker.makeautomarkers", true));
     389        if (layerName != null && Config.getPref().get("draw.rawgps.lines."+layerName).isEmpty()
     390                && Config.getPref().get("draw.rawgps.lines.local."+layerName).isEmpty()) {
    390391            // no line preferences for layer is found
    391392            drawRawGpsLinesGlobal.setSelected(true);
     
    411412        hdopCircleGpsPoints.setSelected(Main.pref.getBoolean("draw.rawgps.hdopcircle", layerName, false));
    412413        largeGpsPoints.setSelected(Main.pref.getBoolean("draw.rawgps.large", layerName, false));
    413         useGpsAntialiasing.setSelected(Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false));
     414        useGpsAntialiasing.setSelected(Config.getPref().getBoolean("mappaint.gpx.use-antialiasing", false));
    414415
    415416        drawRawGpsLinesActionListener.actionPerformed(null);
    416417
    417         if (layerName != null && Main.pref.get("draw.rawgps.colors."+layerName).isEmpty()) {
     418        if (layerName != null && Config.getPref().get("draw.rawgps.colors."+layerName).isEmpty()) {
    418419            colorTypeGlobal.setSelected(true);
    419420            colorDynamic.setSelected(false);
     
    454455            layerNameDot = "";
    455456        }
    456         Main.pref.putBoolean("marker.makeautomarkers"+layerNameDot, makeAutoMarkers.isSelected());
     457        Config.getPref().putBoolean("marker.makeautomarkers"+layerNameDot, makeAutoMarkers.isSelected());
    457458        if (drawRawGpsLinesGlobal.isSelected()) {
    458             Main.pref.put("draw.rawgps.lines" + layerNameDot, null);
    459             Main.pref.put("draw.rawgps.max-line-length" + layerNameDot, null);
    460             Main.pref.put("draw.rawgps.lines.local" + layerNameDot, null);
    461             Main.pref.put("draw.rawgps.max-line-length.local" + layerNameDot, null);
    462             Main.pref.put("draw.rawgps.lines.force"+layerNameDot, null);
    463             Main.pref.put("draw.rawgps.direction"+layerNameDot, null);
    464             Main.pref.put("draw.rawgps.alternatedirection"+layerNameDot, null);
    465             Main.pref.put("draw.rawgps.min-arrow-distance"+layerNameDot, null);
     459            Config.getPref().put("draw.rawgps.lines" + layerNameDot, null);
     460            Config.getPref().put("draw.rawgps.max-line-length" + layerNameDot, null);
     461            Config.getPref().put("draw.rawgps.lines.local" + layerNameDot, null);
     462            Config.getPref().put("draw.rawgps.max-line-length.local" + layerNameDot, null);
     463            Config.getPref().put("draw.rawgps.lines.force"+layerNameDot, null);
     464            Config.getPref().put("draw.rawgps.direction"+layerNameDot, null);
     465            Config.getPref().put("draw.rawgps.alternatedirection"+layerNameDot, null);
     466            Config.getPref().put("draw.rawgps.min-arrow-distance"+layerNameDot, null);
    466467        } else {
    467468            if (layerName == null || !locLayer) {
    468                 Main.pref.putBoolean("draw.rawgps.lines" + layerNameDot, drawRawGpsLinesAll.isSelected());
    469                 Main.pref.put("draw.rawgps.max-line-length" + layerNameDot, drawRawGpsMaxLineLength.getText());
     469                Config.getPref().putBoolean("draw.rawgps.lines" + layerNameDot, drawRawGpsLinesAll.isSelected());
     470                Config.getPref().put("draw.rawgps.max-line-length" + layerNameDot, drawRawGpsMaxLineLength.getText());
    470471            }
    471472            if (layerName == null || locLayer) {
    472                 Main.pref.putBoolean("draw.rawgps.lines.local" + layerNameDot,
     473                Config.getPref().putBoolean("draw.rawgps.lines.local" + layerNameDot,
    473474                        drawRawGpsLinesAll.isSelected() || drawRawGpsLinesLocal.isSelected());
    474                 Main.pref.put("draw.rawgps.max-line-length.local" + layerNameDot,
     475                Config.getPref().put("draw.rawgps.max-line-length.local" + layerNameDot,
    475476                        drawRawGpsMaxLineLengthLocal.getText());
    476477            }
    477             Main.pref.putBoolean("draw.rawgps.lines.force"+layerNameDot, forceRawGpsLines.isSelected());
    478             Main.pref.putBoolean("draw.rawgps.direction"+layerNameDot, drawGpsArrows.isSelected());
    479             Main.pref.putBoolean("draw.rawgps.alternatedirection"+layerNameDot, drawGpsArrowsFast.isSelected());
    480             Main.pref.put("draw.rawgps.min-arrow-distance"+layerNameDot, drawGpsArrowsMinDist.getText());
    481         }
    482 
    483         Main.pref.putBoolean("draw.rawgps.hdopcircle"+layerNameDot, hdopCircleGpsPoints.isSelected());
    484         Main.pref.putBoolean("draw.rawgps.large"+layerNameDot, largeGpsPoints.isSelected());
    485         Main.pref.put("draw.rawgps.linewidth"+layerNameDot, drawLineWidth.getText());
    486         Main.pref.putBoolean("draw.rawgps.lines.alpha-blend"+layerNameDot, drawLineWithAlpha.isSelected());
    487 
    488         Main.pref.putBoolean("mappaint.gpx.use-antialiasing", useGpsAntialiasing.isSelected());
     478            Config.getPref().putBoolean("draw.rawgps.lines.force"+layerNameDot, forceRawGpsLines.isSelected());
     479            Config.getPref().putBoolean("draw.rawgps.direction"+layerNameDot, drawGpsArrows.isSelected());
     480            Config.getPref().putBoolean("draw.rawgps.alternatedirection"+layerNameDot, drawGpsArrowsFast.isSelected());
     481            Config.getPref().put("draw.rawgps.min-arrow-distance"+layerNameDot, drawGpsArrowsMinDist.getText());
     482        }
     483
     484        Config.getPref().putBoolean("draw.rawgps.hdopcircle"+layerNameDot, hdopCircleGpsPoints.isSelected());
     485        Config.getPref().putBoolean("draw.rawgps.large"+layerNameDot, largeGpsPoints.isSelected());
     486        Config.getPref().put("draw.rawgps.linewidth"+layerNameDot, drawLineWidth.getText());
     487        Config.getPref().putBoolean("draw.rawgps.lines.alpha-blend"+layerNameDot, drawLineWithAlpha.isSelected());
     488
     489        Config.getPref().putBoolean("mappaint.gpx.use-antialiasing", useGpsAntialiasing.isSelected());
    489490
    490491        TemplateEntryProperty.forMarker(layerName).put(waypointLabelPattern.getText());
     
    492493
    493494        if (colorTypeGlobal.isSelected()) {
    494             Main.pref.put("draw.rawgps.colors"+layerNameDot, null);
    495             Main.pref.put("draw.rawgps.colors.dynamic"+layerNameDot, null);
    496             Main.pref.put("draw.rawgps.colorTracksTunec"+layerNameDot, null);
     495            Config.getPref().put("draw.rawgps.colors"+layerNameDot, null);
     496            Config.getPref().put("draw.rawgps.colors.dynamic"+layerNameDot, null);
     497            Config.getPref().put("draw.rawgps.colorTracksTunec"+layerNameDot, null);
    497498            return false;
    498499        } else if (colorTypeVelocity.isSelected()) {
    499             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 1);
     500            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 1);
    500501        } else if (colorTypeDilution.isSelected()) {
    501             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 2);
     502            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 2);
    502503        } else if (colorTypeDirection.isSelected()) {
    503             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 3);
     504            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 3);
    504505        } else if (colorTypeTime.isSelected()) {
    505             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 4);
     506            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 4);
    506507        } else if (colorTypeHeatMap.isSelected()) {
    507             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 5);
     508            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 5);
    508509        } else {
    509             Main.pref.putInt("draw.rawgps.colors"+layerNameDot, 0);
    510         }
    511         Main.pref.putBoolean("draw.rawgps.colors.dynamic"+layerNameDot, colorDynamic.isSelected());
     510            Config.getPref().putInt("draw.rawgps.colors"+layerNameDot, 0);
     511        }
     512        Config.getPref().putBoolean("draw.rawgps.colors.dynamic"+layerNameDot, colorDynamic.isSelected());
    512513        int ccti = colorTypeVelocityTune.getSelectedIndex();
    513         Main.pref.putInt("draw.rawgps.colorTracksTune"+layerNameDot, ccti == 2 ? 10 : (ccti == 1 ? 20 : 45));
    514         Main.pref.putInt("draw.rawgps.heatmap.colormap"+layerNameDot, colorTypeHeatMapTune.getSelectedIndex());
    515         Main.pref.putBoolean("draw.rawgps.heatmap.use-points"+layerNameDot, colorTypeHeatMapPoints.isSelected());
    516         Main.pref.putInt("draw.rawgps.heatmap.gain"+layerNameDot, colorTypeHeatMapGain.getValue());
    517         Main.pref.putInt("draw.rawgps.heatmap.lower-limit"+layerNameDot, colorTypeHeatMapLowerLimit.getValue());
     514        Config.getPref().putInt("draw.rawgps.colorTracksTune"+layerNameDot, ccti == 2 ? 10 : (ccti == 1 ? 20 : 45));
     515        Config.getPref().putInt("draw.rawgps.heatmap.colormap"+layerNameDot, colorTypeHeatMapTune.getSelectedIndex());
     516        Config.getPref().putBoolean("draw.rawgps.heatmap.use-points"+layerNameDot, colorTypeHeatMapPoints.isSelected());
     517        Config.getPref().putInt("draw.rawgps.heatmap.gain"+layerNameDot, colorTypeHeatMapGain.getValue());
     518        Config.getPref().putInt("draw.rawgps.heatmap.lower-limit"+layerNameDot, colorTypeHeatMapLowerLimit.getValue());
    518519
    519520        return false;
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/LafPreference.java

    r12841 r12846  
    3939import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    4040import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
     41import org.openstreetmap.josm.spi.preferences.Config;
    4142import org.openstreetmap.josm.tools.GBC;
    4243import org.openstreetmap.josm.tools.Logging;
     
    124125        // Show splash screen on startup
    125126        showSplashScreen.setToolTipText(tr("Show splash screen at startup"));
    126         showSplashScreen.setSelected(Main.pref.getBoolean("draw.splashscreen", true));
     127        showSplashScreen.setSelected(Config.getPref().getBoolean("draw.splashscreen", true));
    127128        panel.add(showSplashScreen, GBC.eop().insets(20, 0, 0, 0));
    128129
    129130        // Show ID in selection
    130131        showID.setToolTipText(tr("Show object ID in selection lists"));
    131         showID.setSelected(Main.pref.getBoolean("osm-primitives.showid", false));
     132        showID.setSelected(Config.getPref().getBoolean("osm-primitives.showid", false));
    132133
    133134        // Show localized names
    134135        showLocalizedName.setToolTipText(tr("Show localized name in selection lists, if available"));
    135         showLocalizedName.setSelected(Main.pref.getBoolean("osm-primitives.localize-name", true));
     136        showLocalizedName.setSelected(Config.getPref().getBoolean("osm-primitives.localize-name", true));
    136137        ExpertToggleAction.addVisibilitySwitcher(showLocalizedName);
    137138
     
    202203    public boolean ok() {
    203204        boolean mod = false;
    204         Main.pref.putBoolean("draw.splashscreen", showSplashScreen.isSelected());
    205         Main.pref.putBoolean("osm-primitives.showid", showID.isSelected());
    206         Main.pref.putBoolean("osm-primitives.localize-name", showLocalizedName.isSelected());
     205        Config.getPref().putBoolean("draw.splashscreen", showSplashScreen.isSelected());
     206        Config.getPref().putBoolean("osm-primitives.showid", showID.isSelected());
     207        Config.getPref().putBoolean("osm-primitives.localize-name", showLocalizedName.isSelected());
    207208        MapFrame.MODELESS.put(modeless.isSelected());
    208         Main.pref.putBoolean(ToggleDialog.PROP_DYNAMIC_BUTTONS.getKey(), dynamicButtons.isSelected());
    209         Main.pref.putBoolean(DateUtils.PROP_ISO_DATES.getKey(), isoDates.isSelected());
    210         Main.pref.putBoolean(FileChooserManager.PROP_USE_NATIVE_FILE_DIALOG.getKey(), nativeFileChoosers.isSelected());
     209        Config.getPref().putBoolean(ToggleDialog.PROP_DYNAMIC_BUTTONS.getKey(), dynamicButtons.isSelected());
     210        Config.getPref().putBoolean(DateUtils.PROP_ISO_DATES.getKey(), isoDates.isSelected());
     211        Config.getPref().putBoolean(FileChooserManager.PROP_USE_NATIVE_FILE_DIALOG.getKey(), nativeFileChoosers.isSelected());
    211212        MapMover.PROP_ZOOM_REVERSE_WHEEL.put(zoomReverseWheel.isSelected());
    212213        NavigatableComponent.PROP_ZOOM_INTERMEDIATE_STEPS.put(zoomIntermediateSteps.isSelected());
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/LanguagePreference.java

    r10134 r12846  
    1818import javax.swing.ListCellRenderer;
    1919
    20 import org.openstreetmap.josm.Main;
    2120import org.openstreetmap.josm.gui.preferences.PreferenceSetting;
    2221import org.openstreetmap.josm.gui.preferences.PreferenceSettingFactory;
     
    2524import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
    2625import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2727import org.openstreetmap.josm.tools.GBC;
    2828import org.openstreetmap.josm.tools.I18n;
     
    5555        // Selecting the language BEFORE the JComboBox listens to model changes speed up initialization by ~35ms (see #7386)
    5656        // See https://stackoverflow.com/questions/3194958/fast-replacement-for-jcombobox-basiccomboboxui
    57         model.selectLanguage(Main.pref.get(LANGUAGE));
     57        model.selectLanguage(Config.getPref().get(LANGUAGE));
    5858        langCombo = new JosmComboBox<>(model);
    5959        langCombo.setRenderer(new LanguageCellRenderer());
     
    7373    public boolean ok() {
    7474        if (langCombo.getSelectedItem() == null)
    75             return Main.pref.put(LANGUAGE, null);
     75            return Config.getPref().put(LANGUAGE, null);
    7676        else
    77             return Main.pref.put(LANGUAGE,
     77            return Config.getPref().put(LANGUAGE,
    7878                    LanguageInfo.getJOSMLocaleCode((Locale) langCombo.getSelectedItem()));
    7979    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/map/MapPaintPreference.java

    r12841 r12846  
    2929import org.openstreetmap.josm.gui.preferences.SubPreferenceSetting;
    3030import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
     31import org.openstreetmap.josm.spi.preferences.Config;
    3132import org.openstreetmap.josm.tools.GBC;
    3233import org.openstreetmap.josm.tools.Logging;
     
    6566    public void addGui(PreferenceTabbedPane gui) {
    6667        enableIconDefault = new JCheckBox(tr("Enable built-in icon defaults"),
    67                 Main.pref.getBoolean("mappaint.icon.enable-defaults", true));
     68                Config.getPref().getBoolean("mappaint.icon.enable-defaults", true));
    6869
    6970        sources = new MapPaintSourceEditor();
     
    105106        @Override
    106107        public Collection<String> getInitialIconPathsList() {
    107             return Main.pref.getList(ICONPREF, null);
     108            return Config.getPref().getList(ICONPREF, null);
    108109        }
    109110
     
    170171    @Override
    171172    public boolean ok() {
    172         boolean reload = Main.pref.putBoolean("mappaint.icon.enable-defaults", enableIconDefault.isSelected());
     173        boolean reload = Config.getPref().putBoolean("mappaint.icon.enable-defaults", enableIconDefault.isSelected());
    173174        reload |= sources.finish();
    174175        if (reload) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/map/TaggingPresetPreference.java

    r12841 r12846  
    3232import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
    3333import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetReader;
     34import org.openstreetmap.josm.spi.preferences.Config;
    3435import org.openstreetmap.josm.tools.GBC;
    3536import org.openstreetmap.josm.tools.Logging;
     
    168169    public void addGui(PreferenceTabbedPane gui) {
    169170        sortMenu = new JCheckBox(tr("Sort presets menu alphabetically"),
    170                 Main.pref.getBoolean("taggingpreset.sortmenu", false));
     171                Config.getPref().getBoolean("taggingpreset.sortmenu", false));
    171172
    172173        final JPanel panel = new JPanel(new GridBagLayout());
     
    206207        @Override
    207208        public Collection<String> getInitialIconPathsList() {
    208             return Main.pref.getList(ICONPREF, null);
     209            return Config.getPref().getList(ICONPREF, null);
    209210        }
    210211
     
    246247    @Override
    247248    public boolean ok() {
    248         boolean restart = Main.pref.putBoolean("taggingpreset.sortmenu", sortMenu.getSelectedObjects() != null);
     249        boolean restart = Config.getPref().putBoolean("taggingpreset.sortmenu", sortMenu.getSelectedObjects() != null);
    249250        restart |= sources.finish();
    250251
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginPreference.java

    r12841 r12846  
    6161import org.openstreetmap.josm.plugins.ReadLocalPluginInformationTask;
    6262import org.openstreetmap.josm.plugins.ReadRemotePluginInformationTask;
     63import org.openstreetmap.josm.spi.preferences.Config;
    6364import org.openstreetmap.josm.tools.GBC;
    6465import org.openstreetmap.josm.tools.ImageProvider;
     
    302303            List<String> l = new LinkedList<>(model.getSelectedPluginNames());
    303304            Collections.sort(l);
    304             Main.pref.putList("plugins", l);
     305            Config.getPref().putList("plugins", l);
    305306            if (!model.getNewlyDeactivatedPlugins().isEmpty())
    306307                return true;
     
    359360                        model.updateAvailablePlugins(task.getAvailablePlugins());
    360361                        pnlPluginPreferences.refreshView();
    361                         Main.pref.putInt("pluginmanager.version", Version.getInstance().getVersion()); // fix #7030
     362                        Config.getPref().putInt("pluginmanager.version", Version.getInstance().getVersion()); // fix #7030
    362363                    });
    363364                }
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginPreferencesModel.java

    r12841 r12846  
    1515import java.util.Set;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.gui.util.ChangeNotifier;
    1918import org.openstreetmap.josm.plugins.PluginException;
    2019import org.openstreetmap.josm.plugins.PluginHandler;
    2120import org.openstreetmap.josm.plugins.PluginInformation;
     21import org.openstreetmap.josm.spi.preferences.Config;
    2222import org.openstreetmap.josm.tools.Logging;
    2323
     
    4040    public PluginPreferencesModel() {
    4141        currentActivePlugins = new HashSet<>();
    42         currentActivePlugins.addAll(Main.pref.getList("plugins"));
     42        currentActivePlugins.addAll(Config.getPref().getList("plugins"));
    4343    }
    4444
     
    8080        filterDisplayedPlugins(filterExpression);
    8181        Set<String> activePlugins = new HashSet<>();
    82         activePlugins.addAll(Main.pref.getList("plugins"));
     82        activePlugins.addAll(Config.getPref().getList("plugins"));
    8383        for (PluginInformation pi: availablePlugins) {
    8484            if (selectedPluginsMap.get(pi) == null && activePlugins.contains(pi.name)) {
     
    230230     */
    231231    public void initFromPreferences() {
    232         Collection<String> enabledPlugins = Main.pref.getList("plugins", null);
     232        Collection<String> enabledPlugins = Config.getPref().getList("plugins", null);
    233233        if (enabledPlugins == null) {
    234234            this.selectedPluginsMap.clear();
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginUpdatePolicyPanel.java

    r12841 r12846  
    2020import javax.swing.event.ChangeListener;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    2423import org.openstreetmap.josm.gui.widgets.JosmTextField;
    2524import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    2625import org.openstreetmap.josm.plugins.PluginHandler;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2727import org.openstreetmap.josm.tools.Logging;
    2828
     
    175175     */
    176176    public final void initFromPreferences() {
    177         rbVersionBasedUpatePolicy.get(Optional.ofNullable(Policy.fromPreferenceValue(
    178                 Main.pref.get("pluginmanager.version-based-update.policy", "ask"))).orElse(Policy.ASK)).setSelected(true);
    179         rbTimeBasedUpatePolicy.get(Optional.ofNullable(Policy.fromPreferenceValue(
    180                 Main.pref.get("pluginmanager.time-based-update.policy", "ask"))).orElse(Policy.ASK)).setSelected(true);
    181 
    182         String pref = Main.pref.get("pluginmanager.warntime", null);
     177        rbVersionBasedUpatePolicy.get(Optional.ofNullable(Policy.fromPreferenceValue(Config.getPref().get("pluginmanager.version-based-update.policy", "ask"))).orElse(Policy.ASK)).setSelected(true);
     178        rbTimeBasedUpatePolicy.get(Optional.ofNullable(Policy.fromPreferenceValue(Config.getPref().get("pluginmanager.time-based-update.policy", "ask"))).orElse(Policy.ASK)).setSelected(true);
     179
     180        String pref = Config.getPref().get("pluginmanager.warntime", null);
    183181        int days = 0;
    184182        if (pref != null) {
    185183            // remove legacy preference
    186             Main.pref.put("pluginmanager.warntime", null);
     184            Config.getPref().put("pluginmanager.warntime", null);
    187185            try {
    188186                days = Integer.parseInt(pref.trim());
     
    196194        }
    197195        if (days == 0) {
    198             days = Main.pref.getInt("pluginmanager.time-based-update.interval", PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL);
     196            days = Config.getPref().getInt("pluginmanager.time-based-update.interval", PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL);
    199197        }
    200198        tfUpdateInterval.setText(Integer.toString(days));
     
    210208        for (Policy p: Policy.values()) {
    211209            if (rbVersionBasedUpatePolicy.get(p).isSelected()) {
    212                 Main.pref.put("pluginmanager.version-based-update.policy", p.getPreferencesValue());
     210                Config.getPref().put("pluginmanager.version-based-update.policy", p.getPreferencesValue());
    213211                break;
    214212            }
     
    219217        for (Policy p: Policy.values()) {
    220218            if (rbTimeBasedUpatePolicy.get(p).isSelected()) {
    221                 Main.pref.put("pluginmanager.time-based-update.policy", p.getPreferencesValue());
     219                Config.getPref().put("pluginmanager.time-based-update.policy", p.getPreferencesValue());
    222220                break;
    223221            }
     
    235233            days = PluginHandler.DEFAULT_TIME_BASED_UPDATE_INTERVAL;
    236234        }
    237         Main.pref.putInt("pluginmanager.time-based-update.interval", days);
     235        Config.getPref().putInt("pluginmanager.time-based-update.interval", days);
    238236    }
    239237
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/CustomProjectionChoice.java

    r12841 r12846  
    2020import javax.swing.plaf.basic.BasicComboBoxEditor;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.data.projection.CustomProjection;
    2423import org.openstreetmap.josm.data.projection.Projection;
     
    3130import org.openstreetmap.josm.gui.widgets.HtmlPanel;
    3231import org.openstreetmap.josm.gui.widgets.JosmTextField;
     32import org.openstreetmap.josm.spi.preferences.Config;
    3333import org.openstreetmap.josm.tools.GBC;
    3434import org.openstreetmap.josm.tools.ImageProvider;
     
    7575                    "+proj=lonlat +ellps=WGS84 +datum=WGS84 +bounds=-180,-90,180,90",
    7676                    "+proj=tmerc +lat_0=0 +lon_0=9 +k_0=1 +x_0=3500000 +y_0=0 +ellps=bessel +nadgrids=BETA2007.gsb");
    77             List<String> inputHistory = new LinkedList<>(Main.pref.getList("projection.custom.value.history", samples));
     77            List<String> inputHistory = new LinkedList<>(Config.getPref().getList("projection.custom.value.history", samples));
    7878            Collections.reverse(inputHistory);
    7979            cbInput.setPossibleItems(inputHistory);
     
    149149        public void rememberHistory() {
    150150            cbInput.addCurrentItemToHistory();
    151             Main.pref.putList("projection.custom.value.history", cbInput.getHistory());
     151            Config.getPref().putList("projection.custom.value.history", cbInput.getHistory());
    152152        }
    153153    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/ProjectionPreference.java

    r12841 r12846  
    4141import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    4242import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
     43import org.openstreetmap.josm.spi.preferences.Config;
    4344import org.openstreetmap.josm.tools.GBC;
    4445import org.openstreetmap.josm.tools.JosmRuntimeException;
     
    482483        }
    483484        id = pc.getId();
    484         Main.pref.putList("projection.sub."+id, pref == null ? null : new ArrayList<>(pref));
     485        Config.getPref().putList("projection.sub."+id, pref == null ? null : new ArrayList<>(pref));
    485486        if (makeDefault) {
    486487            PROP_PROJECTION_DEFAULT.put(id);
     
    560561     */
    561562    public static Collection<String> getSubprojectionPreference(String pcId) {
    562         return Main.pref.getList("projection.sub."+pcId, null);
     563        return Config.getPref().getList("projection.sub."+pcId, null);
    563564    }
    564565
  • trunk/src/org/openstreetmap/josm/gui/preferences/remotecontrol/RemoteControlPreference.java

    r12841 r12846  
    3838import org.openstreetmap.josm.io.remotecontrol.RemoteControlHttpsServer;
    3939import org.openstreetmap.josm.io.remotecontrol.handler.RequestHandler;
     40import org.openstreetmap.josm.spi.preferences.Config;
    4041import org.openstreetmap.josm.tools.GBC;
    4142import org.openstreetmap.josm.tools.Logging;
     
    9394                + tr("JOSM will always listen at <b>port {0}</b> (http) and <b>port {1}</b> (https) on localhost."
    9495                + "<br>These ports are not configurable because they are referenced by external applications talking to JOSM.",
    95                 Main.pref.get("remote.control.port", "8111"),
    96                 Main.pref.get("remote.control.https.port", "8112")) + "</html>");
     96                Config.getPref().get("remote.control.port", "8111"),
     97                Config.getPref().get("remote.control.https.port", "8112")) + "</html>");
    9798        portLabel.setFont(portLabel.getFont().deriveFont(Font.PLAIN));
    9899        remote.add(portLabel, GBC.eol().insets(5, 5, 0, 10).fill(GBC.HORIZONTAL));
     
    167168        remote.add(Box.createVerticalGlue(), GBC.eol().fill(GBC.VERTICAL));
    168169
    169         loadInNewLayer.setSelected(Main.pref.getBoolean(RequestHandler.loadInNewLayerKey, RequestHandler.loadInNewLayerDefault));
    170         alwaysAskUserConfirm.setSelected(Main.pref.getBoolean(RequestHandler.globalConfirmationKey, RequestHandler.globalConfirmationDefault));
     170        loadInNewLayer.setSelected(Config.getPref().getBoolean(RequestHandler.loadInNewLayerKey, RequestHandler.loadInNewLayerDefault));
     171        alwaysAskUserConfirm.setSelected(Config.getPref().getBoolean(RequestHandler.globalConfirmationKey, RequestHandler.globalConfirmationDefault));
    171172
    172173        ActionListener remoteControlEnabled = e -> {
     
    196197        if (enabled) {
    197198            for (Entry<PermissionPrefWithDefault, JCheckBox> p : prefs.entrySet()) {
    198                 Main.pref.putBoolean(p.getKey().pref, p.getValue().isSelected());
    199             }
    200             Main.pref.putBoolean(RequestHandler.loadInNewLayerKey, loadInNewLayer.isSelected());
    201             Main.pref.putBoolean(RequestHandler.globalConfirmationKey, alwaysAskUserConfirm.isSelected());
     199                Config.getPref().putBoolean(p.getKey().pref, p.getValue().isSelected());
     200            }
     201            Config.getPref().putBoolean(RequestHandler.loadInNewLayerKey, loadInNewLayer.isSelected());
     202            Config.getPref().putBoolean(RequestHandler.globalConfirmationKey, alwaysAskUserConfirm.isSelected());
    202203        }
    203204        if (changed) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/AuthenticationPreferencesPanel.java

    r12686 r12846  
    2424import org.openstreetmap.josm.io.OsmApi;
    2525import org.openstreetmap.josm.io.auth.CredentialsManager;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2627import org.openstreetmap.josm.tools.Logging;
    2728
     
    143144            authMethod = "oauth";
    144145        }
    145         Main.pref.put("osm-server.auth-method", authMethod);
     146        Config.getPref().put("osm-server.auth-method", authMethod);
    146147        if ("basic".equals(authMethod)) {
    147148            // save username and password and clear the OAuth token
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/OsmApiUrlInputPanel.java

    r12841 r12846  
    2727import javax.swing.text.JTextComponent;
    2828
    29 import org.openstreetmap.josm.Main;
    3029import org.openstreetmap.josm.data.preferences.ListProperty;
    3130import org.openstreetmap.josm.gui.MainApplication;
     
    3736import org.openstreetmap.josm.io.OsmApiInitializationException;
    3837import org.openstreetmap.josm.io.OsmTransferCanceledException;
     38import org.openstreetmap.josm.spi.preferences.Config;
    3939import org.openstreetmap.josm.tools.ImageProvider;
    4040import org.openstreetmap.josm.tools.Logging;
     
    145145        String hmiUrl = getStrippedApiUrl();
    146146        if (cbUseDefaultServerUrl.isSelected() || OsmApi.DEFAULT_API_URL.equals(hmiUrl)) {
    147             Main.pref.put("osm-server.url", null);
     147            Config.getPref().put("osm-server.url", null);
    148148        } else {
    149             Main.pref.put("osm-server.url", hmiUrl);
     149            Config.getPref().put("osm-server.url", hmiUrl);
    150150            tfOsmServerUrl.addCurrentItemToHistory();
    151151            SERVER_URL_HISTORY.put(tfOsmServerUrl.getHistory());
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/ProxyPreferencesPanel.java

    r12805 r12846  
    2525import javax.swing.JRadioButton;
    2626
    27 import org.openstreetmap.josm.Main;
    2827import org.openstreetmap.josm.gui.help.HelpUtil;
    2928import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
     
    3635import org.openstreetmap.josm.io.auth.CredentialsAgentException;
    3736import org.openstreetmap.josm.io.auth.CredentialsManager;
     37import org.openstreetmap.josm.spi.preferences.Config;
    3838import org.openstreetmap.josm.tools.GBC;
    3939import org.openstreetmap.josm.tools.Logging;
     
    264264     */
    265265    public final void initFromPreferences() {
    266         ProxyPolicy pp = Optional.ofNullable(ProxyPolicy.fromName(Main.pref.get(DefaultProxySelector.PROXY_POLICY, null)))
     266        ProxyPolicy pp = Optional.ofNullable(ProxyPolicy.fromName(Config.getPref().get(DefaultProxySelector.PROXY_POLICY, null)))
    267267                .orElse(ProxyPolicy.NO_PROXY);
    268268        rbProxyPolicy.get(pp).setSelected(true);
    269         String value = Main.pref.get("proxy.host", null);
     269        String value = Config.getPref().get("proxy.host", null);
    270270        if (value != null) {
    271271            // legacy support
    272272            tfProxyHttpHost.setText(value);
    273             Main.pref.put("proxy.host", null);
     273            Config.getPref().put("proxy.host", null);
    274274        } else {
    275             tfProxyHttpHost.setText(Main.pref.get(DefaultProxySelector.PROXY_HTTP_HOST, ""));
    276         }
    277         value = Main.pref.get("proxy.port", null);
     275            tfProxyHttpHost.setText(Config.getPref().get(DefaultProxySelector.PROXY_HTTP_HOST, ""));
     276        }
     277        value = Config.getPref().get("proxy.port", null);
    278278        if (value != null) {
    279279            // legacy support
    280280            tfProxyHttpPort.setText(value);
    281             Main.pref.put("proxy.port", null);
     281            Config.getPref().put("proxy.port", null);
    282282        } else {
    283             tfProxyHttpPort.setText(Main.pref.get(DefaultProxySelector.PROXY_HTTP_PORT, ""));
    284         }
    285         tfProxySocksHost.setText(Main.pref.get(DefaultProxySelector.PROXY_SOCKS_HOST, ""));
    286         tfProxySocksPort.setText(Main.pref.get(DefaultProxySelector.PROXY_SOCKS_PORT, ""));
     283            tfProxyHttpPort.setText(Config.getPref().get(DefaultProxySelector.PROXY_HTTP_PORT, ""));
     284        }
     285        tfProxySocksHost.setText(Config.getPref().get(DefaultProxySelector.PROXY_SOCKS_HOST, ""));
     286        tfProxySocksPort.setText(Config.getPref().get(DefaultProxySelector.PROXY_SOCKS_PORT, ""));
    287287
    288288        if (pp.equals(ProxyPolicy.USE_SYSTEM_SETTINGS) && !DefaultProxySelector.willJvmRetrieveSystemProxies()) {
     
    358358            }
    359359        }
    360         Main.pref.put(DefaultProxySelector.PROXY_POLICY, Optional.ofNullable(policy).orElse(ProxyPolicy.NO_PROXY).getName());
    361         Main.pref.put(DefaultProxySelector.PROXY_HTTP_HOST, tfProxyHttpHost.getText());
    362         Main.pref.put(DefaultProxySelector.PROXY_HTTP_PORT, tfProxyHttpPort.getText());
    363         Main.pref.put(DefaultProxySelector.PROXY_SOCKS_HOST, tfProxySocksHost.getText());
    364         Main.pref.put(DefaultProxySelector.PROXY_SOCKS_PORT, tfProxySocksPort.getText());
     360        Config.getPref().put(DefaultProxySelector.PROXY_POLICY, Optional.ofNullable(policy).orElse(ProxyPolicy.NO_PROXY).getName());
     361        Config.getPref().put(DefaultProxySelector.PROXY_HTTP_HOST, tfProxyHttpHost.getText());
     362        Config.getPref().put(DefaultProxySelector.PROXY_HTTP_PORT, tfProxyHttpPort.getText());
     363        Config.getPref().put(DefaultProxySelector.PROXY_SOCKS_HOST, tfProxySocksHost.getText());
     364        Config.getPref().put(DefaultProxySelector.PROXY_SOCKS_PORT, tfProxySocksPort.getText());
    365365
    366366        // update the proxy selector
  • trunk/src/org/openstreetmap/josm/gui/preferences/validator/ValidatorTagCheckerRulesPreference.java

    r12649 r12846  
    1212import org.openstreetmap.josm.Main;
    1313import org.openstreetmap.josm.data.preferences.sources.ExtendedSourceEntry;
    14 import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
    1514import org.openstreetmap.josm.data.preferences.sources.SourceEntry;
    1615import org.openstreetmap.josm.data.preferences.sources.SourceProvider;
    1716import org.openstreetmap.josm.data.preferences.sources.SourceType;
     17import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
    1818import org.openstreetmap.josm.data.validation.OsmValidator;
    1919import org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker;
  • trunk/src/org/openstreetmap/josm/gui/preferences/validator/ValidatorTestsPreference.java

    r12841 r12846  
    1616import javax.swing.JPanel;
    1717
    18 import org.openstreetmap.josm.Main;
    1918import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
    2019import org.openstreetmap.josm.data.validation.OsmValidator;
     
    2827import org.openstreetmap.josm.gui.util.GuiHelper;
    2928import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
     29import org.openstreetmap.josm.spi.preferences.Config;
    3030import org.openstreetmap.josm.tools.GBC;
    3131
     
    116116        OsmValidator.initializeTests(testsToInitialize);
    117117
    118         Main.pref.putList(ValidatorPrefHelper.PREF_SKIP_TESTS, tests);
    119         Main.pref.putList(ValidatorPrefHelper.PREF_SKIP_TESTS_BEFORE_UPLOAD, testsBeforeUpload);
     118        Config.getPref().putList(ValidatorPrefHelper.PREF_SKIP_TESTS, tests);
     119        Config.getPref().putList(ValidatorPrefHelper.PREF_SKIP_TESTS_BEFORE_UPLOAD, testsBeforeUpload);
    120120        ValidatorPrefHelper.PREF_USE_IGNORE.put(prefUseIgnore.isSelected());
    121121        ValidatorPrefHelper.PREF_OTHER.put(prefOther.isSelected());
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletingComboBox.java

    r12630 r12846  
    2323import javax.swing.text.StyleConstants;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.gui.MainApplication;
    2726import org.openstreetmap.josm.gui.MapFrame;
    2827import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
    2928import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     29import org.openstreetmap.josm.spi.preferences.Config;
    3030import org.openstreetmap.josm.tools.Logging;
    3131
     
    140140            Object item;
    141141            // if the text is a number we don't autocomplete
    142             if (Main.pref.getBoolean("autocomplete.dont_complete_numbers", true)) {
     142            if (Config.getPref().getBoolean("autocomplete.dont_complete_numbers", true)) {
    143143                try {
    144144                    Long.parseLong(str);
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletingTextField.java

    r12620 r12846  
    2020import javax.swing.text.StyleConstants;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.gui.util.CellEditorSupport;
    2423import org.openstreetmap.josm.gui.widgets.JosmTextField;
     24import org.openstreetmap.josm.spi.preferences.Config;
    2525import org.openstreetmap.josm.tools.Logging;
    2626
     
    7979            String currentText = getText(0, getLength());
    8080            // if the text starts with a number we don't autocomplete
    81             if (Main.pref.getBoolean("autocomplete.dont_complete_numbers", true)) {
     81            if (Config.getPref().getBoolean("autocomplete.dont_complete_numbers", true)) {
    8282                try {
    8383                    Long.parseLong(str);
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPreset.java

    r12841 r12846  
    6060import org.openstreetmap.josm.gui.tagging.presets.items.Space;
    6161import org.openstreetmap.josm.gui.util.GuiHelper;
     62import org.openstreetmap.josm.spi.preferences.Config;
    6263import org.openstreetmap.josm.tools.GBC;
    6364import org.openstreetmap.josm.tools.ImageProvider;
     
    210211        }
    211212        File arch = TaggingPresetReader.getZipIcons();
    212         final Collection<String> s = Main.pref.getList("taggingpreset.icon.sources", null);
     213        final Collection<String> s = Config.getPref().getList("taggingpreset.icon.sources", null);
    213214        ImageProvider imgProv = new ImageProvider(iconName);
    214215        imgProv.setDirs(s);
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetItem.java

    r12841 r12846  
    2424import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
    2525import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionManager;
     26import org.openstreetmap.josm.spi.preferences.Config;
    2627import org.openstreetmap.josm.tools.ImageProvider;
    2728import org.openstreetmap.josm.tools.Logging;
     
    127128
    128129    protected static ImageIcon loadImageIcon(String iconName, File zipIcons, Integer maxSize) {
    129         final Collection<String> s = Main.pref.getList("taggingpreset.icon.sources", null);
     130        final Collection<String> s = Config.getPref().getList("taggingpreset.icon.sources", null);
    130131        ImageProvider imgProv = new ImageProvider(iconName).setDirs(s).setId("presets").setArchive(zipIcons).setOptional(true);
    131132        if (maxSize != null) {
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresets.java

    r12841 r12846  
    1414import javax.swing.JSeparator;
    1515
    16 import org.openstreetmap.josm.Main;
    1716import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1817import org.openstreetmap.josm.gui.MainApplication;
     
    2221import org.openstreetmap.josm.gui.tagging.presets.items.Roles;
    2322import org.openstreetmap.josm.gui.tagging.presets.items.Roles.Role;
     23import org.openstreetmap.josm.spi.preferences.Config;
    2424import org.openstreetmap.josm.tools.Logging;
    2525import org.openstreetmap.josm.tools.MultiMap;
     
    9191            }
    9292            for (JMenu submenu : submenus.values()) {
    93                 if (submenu.getItemCount() >= Main.pref.getInt("taggingpreset.min-elements-for-scroller", 15)) {
     93                if (submenu.getItemCount() >= Config.getPref().getInt("taggingpreset.min-elements-for-scroller", 15)) {
    9494                    MenuScroller.setScrollerFor(submenu);
    9595                }
    9696            }
    9797        }
    98         if (Main.pref.getBoolean("taggingpreset.sortmenu")) {
     98        if (Config.getPref().getBoolean("taggingpreset.sortmenu")) {
    9999            TaggingPresetMenu.sortMenu(MainApplication.getMenu().presetsMenu);
    100100        }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/Combo.java

    r11452 r12846  
    44import javax.swing.JPanel;
    55
    6 import org.openstreetmap.josm.Main;
    76import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
    87import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPriority;
    98import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
    109import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     10import org.openstreetmap.josm.spi.preferences.Config;
    1111import org.openstreetmap.josm.tools.GBC;
    1212
     
    5656        AutoCompletingTextField tf = new AutoCompletingTextField();
    5757        initAutoCompletionField(tf, key);
    58         if (Main.pref.getBoolean("taggingpreset.display-keys-as-hint", true)) {
     58        if (Config.getPref().getBoolean("taggingpreset.display-keys-as-hint", true)) {
    5959            tf.setHint(key);
    6060        }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/ComboMultiSelect.java

    r12620 r12846  
    3131import javax.swing.ListModel;
    3232
    33 import org.openstreetmap.josm.Main;
    3433import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3534import org.openstreetmap.josm.data.osm.Tag;
    3635import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetReader;
    3736import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetSelector;
     37import org.openstreetmap.josm.spi.preferences.Config;
    3838import org.openstreetmap.josm.tools.AlphanumComparator;
    3939import org.openstreetmap.josm.tools.GBC;
     
    493493        }
    494494
    495         if (values_sort && Main.pref.getBoolean("taggingpreset.sortvalues", true)) {
     495        if (values_sort && Config.getPref().getBoolean("taggingpreset.sortvalues", true)) {
    496496            Collections.sort(entries);
    497497        }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/Roles.java

    r12659 r12846  
    1515import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1616import org.openstreetmap.josm.data.osm.Tag;
     17import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    1718import org.openstreetmap.josm.data.osm.search.SearchParseError;
    1819import org.openstreetmap.josm.data.osm.search.SearchSetting;
    19 import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    2020import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetItem;
    2121import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetType;
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/Text.java

    r12620 r12846  
    2222import javax.swing.JToggleButton;
    2323
    24 import org.openstreetmap.josm.Main;
    2524import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2625import org.openstreetmap.josm.data.osm.Tag;
     
    2928import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    3029import org.openstreetmap.josm.gui.widgets.JosmTextField;
     30import org.openstreetmap.josm.spi.preferences.Config;
    3131import org.openstreetmap.josm.tools.GBC;
    3232import org.openstreetmap.josm.tools.Logging;
     
    7272            initAutoCompletionField(textField, key);
    7373        }
    74         if (Main.pref.getBoolean("taggingpreset.display-keys-as-hint", true)) {
     74        if (Config.getPref().getBoolean("taggingpreset.display-keys-as-hint", true)) {
    7575            textField.setHint(key);
    7676        }
  • trunk/src/org/openstreetmap/josm/gui/util/WindowGeometry.java

    r12678 r12846  
    2020
    2121import org.openstreetmap.josm.Main;
     22import org.openstreetmap.josm.spi.preferences.Config;
    2223import org.openstreetmap.josm.tools.CheckParameterUtil;
    2324import org.openstreetmap.josm.tools.JosmRuntimeException;
     
    206207
    207208    protected final void initFromPreferences(String preferenceKey) throws WindowGeometryException {
    208         String value = Main.pref.get(preferenceKey);
     209        String value = Config.getPref().get(preferenceKey);
    209210        if (value.isEmpty())
    210211            throw new WindowGeometryException(
     
    275276        value.append("x=").append(topLeft.x).append(",y=").append(topLeft.y)
    276277             .append(",width=").append(extent.width).append(",height=").append(extent.height);
    277         Main.pref.put(preferenceKey, value.toString());
     278        Config.getPref().put(preferenceKey, value.toString());
    278279    }
    279280
  • trunk/src/org/openstreetmap/josm/gui/widgets/CompileSearchTextDecorator.java

    r12656 r12846  
    99import javax.swing.text.JTextComponent;
    1010
     11import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    1112import org.openstreetmap.josm.data.osm.search.SearchParseError;
    12 import org.openstreetmap.josm.data.osm.search.SearchCompiler;
    1313import org.openstreetmap.josm.tools.Logging;
    1414
  • trunk/src/org/openstreetmap/josm/gui/widgets/FileChooserManager.java

    r9991 r12846  
    1515import org.openstreetmap.josm.actions.SaveActionBase;
    1616import org.openstreetmap.josm.data.preferences.BooleanProperty;
     17import org.openstreetmap.josm.spi.preferences.Config;
    1718
    1819/**
     
    9091        this.open = open;
    9192        this.lastDirProperty = lastDirProperty == null || lastDirProperty.isEmpty() ? "lastDirectory" : lastDirProperty;
    92         this.curDir = Main.pref.get(this.lastDirProperty).isEmpty() ?
     93        this.curDir = Config.getPref().get(this.lastDirProperty).isEmpty() ?
    9394                defaultDir == null || defaultDir.isEmpty() ? "." : defaultDir
    94                 : Main.pref.get(this.lastDirProperty);
     95                : Config.getPref().get(this.lastDirProperty);
    9596    }
    9697
     
    345346
    346347        if (!fc.getCurrentDirectory().getAbsolutePath().equals(curDir)) {
    347             Main.pref.put(lastDirProperty, fc.getCurrentDirectory().getAbsolutePath());
     348            Config.getPref().put(lastDirProperty, fc.getCurrentDirectory().getAbsolutePath());
    348349        }
    349350
  • trunk/src/org/openstreetmap/josm/gui/widgets/HistoryComboBox.java

    r12841 r12846  
    66import javax.swing.text.JTextComponent;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingComboBox;
     9import org.openstreetmap.josm.spi.preferences.Config;
    1010
    1111/**
     
    2424     */
    2525    public HistoryComboBox() {
    26         int maxsize = Main.pref.getInt("search.history-size", DEFAULT_SEARCH_HISTORY_SIZE);
     26        int maxsize = Config.getPref().getInt("search.history-size", DEFAULT_SEARCH_HISTORY_SIZE);
    2727        model = new ComboBoxHistory(maxsize);
    2828        setModel(model);
  • trunk/src/org/openstreetmap/josm/gui/widgets/TextContextualPopupMenu.java

    r12620 r12846  
    2323import javax.swing.undo.UndoManager;
    2424
    25 import org.openstreetmap.josm.Main;
     25import org.openstreetmap.josm.spi.preferences.Config;
    2626import org.openstreetmap.josm.tools.ImageProvider;
    2727import org.openstreetmap.josm.tools.Logging;
     
    172172            JMenuItem mi = new JMenuItem(action);
    173173            mi.setText(label);
    174             if (iconName != null && Main.pref.getBoolean("text.popupmenu.useicons", true)) {
     174            if (iconName != null && Config.getPref().getBoolean("text.popupmenu.useicons", true)) {
    175175                ImageIcon icon = ImageProvider.get(iconName, ImageProvider.ImageSizes.SMALLICON);
    176176                if (icon != null) {
Note: See TracChangeset for help on using the changeset viewer.