Ignore:
Timestamp:
2017-08-22T22:26:32+02:00 (3 years ago)
Author:
Don-vip
Message:

see #15182 - deprecate all Main logging methods and introduce suitable replacements in Logging for most of them

Location:
trunk/src/org/openstreetmap/josm/data
Files:
53 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/AutosaveTask.java

    r12374 r12620  
    4646import org.openstreetmap.josm.io.OsmExporter;
    4747import org.openstreetmap.josm.io.OsmImporter;
     48import org.openstreetmap.josm.tools.Logging;
    4849import org.openstreetmap.josm.tools.Utils;
    4950
     
    134135
    135136            if (!autosaveDir.exists() && !autosaveDir.mkdirs()) {
    136                 Main.warn(tr("Unable to create directory {0}, autosave will be disabled", autosaveDir.getAbsolutePath()));
     137                Logging.warn(tr("Unable to create directory {0}, autosave will be disabled", autosaveDir.getAbsolutePath()));
    137138                return;
    138139            }
    139140            if (!deletedLayersDir.exists() && !deletedLayersDir.mkdirs()) {
    140                 Main.warn(tr("Unable to create directory {0}, autosave will be disabled", deletedLayersDir.getAbsolutePath()));
     141                Logging.warn(tr("Unable to create directory {0}, autosave will be disabled", deletedLayersDir.getAbsolutePath()));
    141142                return;
    142143            }
     
    200201                    return result;
    201202                } else {
    202                     Main.warn(tr("Unable to create file {0}, other filename will be used", result.getAbsolutePath()));
     203                    Logging.warn(tr("Unable to create file {0}, other filename will be used", result.getAbsolutePath()));
    203204                }
    204205            } catch (IOException e) {
    205                 Main.error(e, tr("IOError while creating file, autosave will be skipped: {0}", e.getMessage()));
     206                Logging.log(Logging.LEVEL_ERROR, tr("IOError while creating file, autosave will be skipped: {0}", e.getMessage()), e);
    206207                return null;
    207208            }
     
    215216            ps.println(ManagementFactory.getRuntimeMXBean().getName());
    216217        } catch (IOException | SecurityException t) {
    217             Main.error(t);
     218            Logging.error(t);
    218219        }
    219220    }
     
    252253            } catch (RuntimeException t) { // NOPMD
    253254                // Don't let exception stop time thread
    254                 Main.error("Autosave failed:");
    255                 Main.error(t);
     255                Logging.error("Autosave failed:");
     256                Logging.error(t);
    256257            }
    257258        }
     
    343344                        }
    344345                    } catch (IOException | SecurityException t) {
    345                         Main.error(t);
     346                        Logging.error(t);
    346347                    }
    347348                }
     
    379380                }
    380381            } catch (InterruptedException | ExecutionException e) {
    381                 Main.error(e);
     382                Logging.error(e);
    382383            }
    383384        });
     
    404405            Utils.deleteFile(pidFile);
    405406        } else {
    406             Main.warn(String.format("Could not move autosaved file %s to %s folder", f.getName(), deletedLayersDir.getName()));
     407            Logging.warn(String.format("Could not move autosaved file %s to %s folder", f.getName(), deletedLayersDir.getName()));
    407408            // we cannot move to deleted folder, so just try to delete it directly
    408409            if (Utils.deleteFile(f, marktr("Unable to delete backup file {0}"))) {
  • trunk/src/org/openstreetmap/josm/data/CustomConfigurator.java

    r11535 r12620  
    5555import org.openstreetmap.josm.plugins.ReadLocalPluginInformationTask;
    5656import org.openstreetmap.josm.tools.LanguageInfo;
     57import org.openstreetmap.josm.tools.Logging;
    5758import org.openstreetmap.josm.tools.Utils;
    5859import org.w3c.dom.DOMException;
     
    100101     */
    101102    public static void log(Exception e, String s) {
    102         summary.append(s).append(' ').append(Main.getErrorMessage(e)).append('\n');
     103        summary.append(s).append(' ').append(Logging.getErrorMessage(e)).append('\n');
    103104    }
    104105
     
    206207            case 'q': JOptionPane.showMessageDialog(Main.parent, text, tr("Question"), JOptionPane.QUESTION_MESSAGE); break;
    207208            case 'p': JOptionPane.showMessageDialog(Main.parent, text, tr("Message"), JOptionPane.PLAIN_MESSAGE); break;
    208             default: Main.warn("Unsupported messageBox type: " + c);
     209            default: Logging.warn("Unsupported messageBox type: " + c);
    209210        }
    210211    }
     
    281282            root = document.getDocumentElement();
    282283        } catch (SAXException | IOException | ParserConfigurationException ex) {
    283             Main.warn(ex, "Error getting preferences to save:");
     284            Logging.log(Logging.LEVEL_WARN, "Error getting preferences to save:", ex);
    284285        }
    285286        if (root == null || exportDocument == null)
     
    310311            ts.transform(new DOMSource(exportDocument), new StreamResult(f.toURI().getPath()));
    311312        } catch (DOMException | TransformerFactoryConfigurationError | TransformerException ex) {
    312             Main.warn("Error saving preferences part:");
    313             Main.error(ex);
     313            Logging.warn("Error saving preferences part:");
     314            Logging.error(ex);
    314315        }
    315316    }
     
    375376                    while (busy) CustomConfigurator.class.wait();
    376377                } catch (InterruptedException ex) {
    377                     Main.warn(ex, "InterruptedException while reading local plugin information");
     378                    Logging.log(Logging.LEVEL_WARN, "InterruptedException while reading local plugin information", ex);
    378379                    Thread.currentThread().interrupt();
    379380                }
     
    495496            } catch (ScriptException ex) {
    496497                log("Error: initializing script engine: "+ex.getMessage());
    497                 Main.error(ex);
     498                Logging.error(ex);
    498499            }
    499500        }
     
    961962
    962963    private static void showPrefs(Preferences tmpPref) {
    963         Main.info("properties: " + tmpPref.settingsMap);
     964        Logging.info("properties: " + tmpPref.settingsMap);
    964965    }
    965966
  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r12601 r12620  
    7878import org.openstreetmap.josm.tools.JosmRuntimeException;
    7979import org.openstreetmap.josm.tools.ListenerList;
     80import org.openstreetmap.josm.tools.Logging;
    8081import org.openstreetmap.josm.tools.MultiMap;
    8182import org.openstreetmap.josm.tools.Utils;
     
    414415        }
    415416        if (!cacheDir.exists() && !cacheDir.mkdirs()) {
    416             Main.warn(tr("Failed to create missing cache directory: {0}", cacheDir.getAbsoluteFile()));
     417            Logging.warn(tr("Failed to create missing cache directory: {0}", cacheDir.getAbsoluteFile()));
    417418            JOptionPane.showMessageDialog(
    418419                    Main.parent,
     
    671672
    672673    private static void setCorrectPermissions(File file) {
    673         if (!file.setReadable(false, false) && Main.isTraceEnabled()) {
    674             Main.trace(tr("Unable to set file non-readable {0}", file.getAbsolutePath()));
    675         }
    676         if (!file.setWritable(false, false) && Main.isTraceEnabled()) {
    677             Main.trace(tr("Unable to set file non-writable {0}", file.getAbsolutePath()));
    678         }
    679         if (!file.setExecutable(false, false) && Main.isTraceEnabled()) {
    680             Main.trace(tr("Unable to set file non-executable {0}", file.getAbsolutePath()));
    681         }
    682         if (!file.setReadable(true, true) && Main.isTraceEnabled()) {
    683             Main.trace(tr("Unable to set file readable {0}", file.getAbsolutePath()));
    684         }
    685         if (!file.setWritable(true, true) && Main.isTraceEnabled()) {
    686             Main.trace(tr("Unable to set file writable {0}", file.getAbsolutePath()));
     674        if (!file.setReadable(false, false) && Logging.isTraceEnabled()) {
     675            Logging.trace(tr("Unable to set file non-readable {0}", file.getAbsolutePath()));
     676        }
     677        if (!file.setWritable(false, false) && Logging.isTraceEnabled()) {
     678            Logging.trace(tr("Unable to set file non-writable {0}", file.getAbsolutePath()));
     679        }
     680        if (!file.setExecutable(false, false) && Logging.isTraceEnabled()) {
     681            Logging.trace(tr("Unable to set file non-executable {0}", file.getAbsolutePath()));
     682        }
     683        if (!file.setReadable(true, true) && Logging.isTraceEnabled()) {
     684            Logging.trace(tr("Unable to set file readable {0}", file.getAbsolutePath()));
     685        }
     686        if (!file.setWritable(true, true) && Logging.isTraceEnabled()) {
     687            Logging.trace(tr("Unable to set file writable {0}", file.getAbsolutePath()));
    687688        }
    688689    }
     
    751752        if (prefDir.exists()) {
    752753            if (!prefDir.isDirectory()) {
    753                 Main.warn(tr("Failed to initialize preferences. Preference directory ''{0}'' is not a directory.",
     754                Logging.warn(tr("Failed to initialize preferences. Preference directory ''{0}'' is not a directory.",
    754755                        prefDir.getAbsoluteFile()));
    755756                JOptionPane.showMessageDialog(
     
    764765        } else {
    765766            if (!prefDir.mkdirs()) {
    766                 Main.warn(tr("Failed to initialize preferences. Failed to create missing preference directory: {0}",
     767                Logging.warn(tr("Failed to initialize preferences. Failed to create missing preference directory: {0}",
    767768                        prefDir.getAbsoluteFile()));
    768769                JOptionPane.showMessageDialog(
     
    780781        try {
    781782            if (!preferenceFile.exists()) {
    782                 Main.info(tr("Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
     783                Logging.info(tr("Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
    783784                resetToDefault();
    784785                save();
     
    786787                File backupFile = new File(prefDir, "preferences.xml.bak");
    787788                Main.platform.rename(preferenceFile, backupFile);
    788                 Main.warn(tr("Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
     789                Logging.warn(tr("Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
    789790                resetToDefault();
    790791                save();
    791792            }
    792793        } catch (IOException e) {
    793             Main.error(e);
     794            Logging.error(e);
    794795            JOptionPane.showMessageDialog(
    795796                    Main.parent,
     
    805806            initSuccessful = true;
    806807        } catch (IOException | SAXException | XMLStreamException e) {
    807             Main.error(e);
     808            Logging.error(e);
    808809            File backupFile = new File(prefDir, "preferences.xml.bak");
    809810            JOptionPane.showMessageDialog(
     
    820821                save();
    821822            } catch (IOException e1) {
    822                 Main.error(e1);
    823                 Main.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
     823                Logging.error(e1);
     824                Logging.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
    824825            }
    825826        }
     
    829830                loadDefaults();
    830831            } catch (IOException | XMLStreamException | SAXException e) {
    831                 Main.error(e);
    832                 Main.warn(tr("Failed to load defaults cache file: {0}", def));
     832                Logging.error(e);
     833                Logging.warn(tr("Failed to load defaults cache file: {0}", def));
    833834                defaultsMap.clear();
    834835                if (!def.delete()) {
    835                     Main.warn(tr("Failed to delete faulty defaults cache file: {0}", def));
     836                    Logging.warn(tr("Failed to delete faulty defaults cache file: {0}", def));
    836837                }
    837838            }
     
    966967        } catch (NumberFormatException e) {
    967968            // fall out
    968             Main.trace(e);
     969            Logging.trace(e);
    969970        }
    970971        return def;
     
    989990        } catch (NumberFormatException e) {
    990991            // fall out
    991             Main.trace(e);
     992            Logging.trace(e);
    992993        }
    993994        return def;
     
    10101011        } catch (NumberFormatException e) {
    10111012            // fall out
    1012             Main.trace(e);
     1013            Logging.trace(e);
    10131014        }
    10141015        return def;
     
    10311032        } catch (NumberFormatException e) {
    10321033            // fall out
    1033             Main.trace(e);
     1034            Logging.trace(e);
    10341035        }
    10351036        return def;
     
    10991100                    save();
    11001101                } catch (IOException e) {
    1101                     Main.warn(e, tr("Failed to persist preferences to ''{0}''", getPreferenceFile().getAbsoluteFile()));
     1102                    Logging.log(Logging.LEVEL_WARN, tr("Failed to persist preferences to ''{0}''", getPreferenceFile().getAbsoluteFile()), e);
    11021103                }
    11031104            }
     
    11331134        Setting<?> oldDef = defaultsMap.get(key);
    11341135        if (oldDef != null && oldDef.isNew() && oldDef.getValue() != null && def.getValue() != null && !def.equals(oldDef)) {
    1135             Main.info("Defaults for " + key + " differ: " + def + " != " + defaultsMap.get(key));
     1136            Logging.info("Defaults for " + key + " differ: " + def + " != " + defaultsMap.get(key));
    11361137        }
    11371138        if (def.getValue() != null || oldDef == null) {
     
    14631464                f = klass.getDeclaredField(keyValue.getKey().replace('-', '_'));
    14641465            } catch (NoSuchFieldException ex) {
    1465                 Main.trace(ex);
     1466                Logging.trace(ex);
    14661467                continue;
    14671468            }
     
    15261527        if ("true".equals(get("prefer.ipv6", "auto")) && !"true".equals(Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true"))) {
    15271528            // never set this to false, only true!
    1528             Main.info(tr("Try enabling IPv6 network, prefering IPv6 over IPv4 (only works on early startup)."));
     1529            Logging.info(tr("Try enabling IPv6 network, prefering IPv6 over IPv4 (only works on early startup)."));
    15291530        }
    15301531        Utils.updateSystemProperty("http.agent", Version.getInstance().getAgentString());
     
    15401541            } catch (ReflectiveOperationException | RuntimeException e) { // NOPMD
    15411542                // Catch RuntimeException in order to catch InaccessibleObjectException, new in Java 9
    1542                 Main.warn(e);
     1543                Logging.warn(e);
    15431544            }
    15441545        }
     
    15711572                OnlineResource.JOSM_WEBSITE.checkOfflineAccess(it.next(), Main.getJOSMWebsite());
    15721573            } catch (OfflineAccessException ex) {
    1573                 Main.warn(ex, false);
     1574                Logging.log(Logging.LEVEL_WARN, ex);
    15741575                it.remove();
    15751576            }
     
    16131614            return sw.toString();
    16141615        } catch (IOException e) {
    1615             Main.error(e);
     1616            Logging.error(e);
    16161617            return null;
    16171618        }
     
    16431644            if (settingsMap.containsKey(key)) {
    16441645                settingsMap.remove(key);
    1645                 Main.info(tr("Preference setting {0} has been removed since it is no longer used.", key));
     1646                Logging.info(tr("Preference setting {0} has been removed since it is no longer used.", key));
    16461647            }
    16471648        }
     
    16561657                    final String oldKey = entry.getKey();
    16571658                    final String newKey = entry.getValue();
    1658                     Main.info("Migrating old color key {0} => {1}", oldKey, newKey);
     1659                    Logging.info("Migrating old color key {0} => {1}", oldKey, newKey);
    16591660                    put(newKey, get(oldKey));
    16601661                    put(oldKey, null);
  • trunk/src/org/openstreetmap/josm/data/Version.java

    r11899 r12620  
    1212import org.openstreetmap.josm.Main;
    1313import org.openstreetmap.josm.tools.LanguageInfo;
     14import org.openstreetmap.josm.tools.Logging;
    1415
    1516/**
     
    6061            properties.load(revisionInfo);
    6162        } catch (IOException e) {
    62             Main.warn(e, tr("Error reading revision info from revision file: {0}", e.getMessage()));
     63            Logging.log(Logging.LEVEL_WARN, tr("Error reading revision info from revision file: {0}", e.getMessage()), e);
    6364        }
    6465        String value = Optional.ofNullable(properties.getProperty("Revision")).orElse("").trim();
     
    6869            } catch (NumberFormatException e) {
    6970                version = 0;
    70                 Main.warn(tr("Unexpected JOSM version number in revision file, value is ''{0}''", value));
     71                Logging.warn(tr("Unexpected JOSM version number in revision file, value is ''{0}''", value));
    7172            }
    7273        } else {
     
    105106        try (InputStream stream = Main.class.getResourceAsStream("/REVISION")) {
    106107            if (stream == null) {
    107                 Main.warn(tr("The revision file ''/REVISION'' is missing."));
     108                Logging.warn(tr("The revision file ''/REVISION'' is missing."));
    108109                version = 0;
    109110                releaseDescription = "";
     
    112113            initFromRevisionInfo(stream);
    113114        } catch (IOException e) {
    114             Main.warn(e);
     115            Logging.warn(e);
    115116        }
    116117    }
  • trunk/src/org/openstreetmap/josm/data/cache/CacheEntryAttributes.java

    r12279 r12620  
    1111
    1212import org.apache.commons.jcs.engine.ElementAttributes;
    13 import org.openstreetmap.josm.Main;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    162162        for (Entry<String, String> e: map.entrySet()) {
    163163            if (RESERVED_KEYS.contains(e.getKey())) {
    164                 Main.info("Metadata key configuration contains key {0} which is reserved for internal use");
     164                Logging.info("Metadata key configuration contains key {0} which is reserved for internal use");
    165165            } else {
    166166                attrs.put(e.getKey(), e.getValue());
     
    191191     */
    192192    public void setError(Exception error) {
    193         setErrorMessage(Main.getErrorMessage(error));
     193        setErrorMessage(Logging.getErrorMessage(error));
    194194    }
    195195
  • trunk/src/org/openstreetmap/josm/data/cache/HostLimitQueue.java

    r11546 r12620  
    1212import java.util.concurrent.TimeUnit;
    1313
    14 import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.tools.Logging;
    1515
    1616/**
     
    6767                        url = job.getUrl();
    6868                    } catch (IOException e) {
    69                         Main.debug(e);
     69                        Logging.debug(e);
    7070                    }
    71                     Main.debug("TMS - Skipping job {0} because host limit reached", url);
     71                    Logging.debug("TMS - Skipping job {0} because host limit reached", url);
    7272                }
    7373            }
     
    9090                // acquire my got interrupted, first offer back what was taken
    9191                if (!offer(job)) {
    92                     Main.warn("Unable to offer back " + job);
     92                    Logging.warn("Unable to offer back " + job);
    9393                }
    9494                throw e;
     
    110110            // acquire my got interrupted, first offer back what was taken
    111111            if (!offer(job)) {
    112                 Main.warn("Unable to offer back " + job);
     112                Logging.warn("Unable to offer back " + job);
    113113            }
    114114            throw e;
     
    209209            limit.release();
    210210            if (limit.availablePermits() > hostLimit) {
    211                 Main.warn("More permits than it should be");
     211                Logging.warn("More permits than it should be");
    212212            }
    213213        }
  • trunk/src/org/openstreetmap/josm/data/cache/JCSCacheManager.java

    r12537 r12620  
    3131import org.openstreetmap.josm.data.preferences.BooleanProperty;
    3232import org.openstreetmap.josm.data.preferences.IntegerProperty;
     33import org.openstreetmap.josm.tools.Logging;
    3334import org.openstreetmap.josm.tools.Utils;
    3435
     
    9192                String msg = formatter.formatMessage(record);
    9293                if (record.getLevel().intValue() >= Level.SEVERE.intValue()) {
    93                     Main.error(msg);
     94                    Logging.error(msg);
    9495                } else if (record.getLevel().intValue() >= Level.WARNING.intValue()) {
    95                     Main.warn(msg);
     96                    Logging.warn(msg);
    9697                    // downgrade INFO level to debug, as JCS is too verbose at INFO level
    9798                } else if (record.getLevel().intValue() >= Level.INFO.intValue()) {
    98                     Main.debug(msg);
     99                    Logging.debug(msg);
    99100                } else {
    100                     Main.trace(msg);
     101                    Logging.trace(msg);
    101102                }
    102103            }
  • trunk/src/org/openstreetmap/josm/data/cache/JCSCachedTileLoaderJob.java

    r12542 r12620  
    2222import org.apache.commons.jcs.engine.behavior.ICacheElement;
    2323import org.openstreetmap.gui.jmapviewer.FeatureAdapter;
    24 import org.openstreetmap.josm.Main;
    2524import org.openstreetmap.josm.data.cache.ICachedLoaderListener.LoadResult;
    2625import org.openstreetmap.josm.data.preferences.IntegerProperty;
    2726import org.openstreetmap.josm.tools.CheckParameterUtil;
    2827import org.openstreetmap.josm.tools.HttpClient;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.Utils;
    3030
     
    216216            return getUrl().getHost();
    217217        } catch (IOException e) {
    218             Main.trace(e);
     218            Logging.trace(e);
    219219            return null;
    220220        }
     
    264264            } catch (IOException e) {
    265265                listeners = null;
    266                 Main.trace(e);
     266                Logging.trace(e);
    267267            }
    268268        }
     
    406406            attributes.setError(e);
    407407            LOG.log(Level.WARNING, "JCS - Exception during download {0}", getUrlNoException());
    408             Main.warn(e);
     408            Logging.warn(e);
    409409            Thread.currentThread().interrupt();
    410410        }
     
    446446            } catch (NumberFormatException e) {
    447447                // ignore malformed Cache-Control headers
    448                 Main.trace(e);
     448                Logging.trace(e);
    449449            }
    450450        }
  • trunk/src/org/openstreetmap/josm/data/coor/LatLon.java

    r12561 r12620  
    2626import org.openstreetmap.josm.Main;
    2727import org.openstreetmap.josm.data.Bounds;
     28import org.openstreetmap.josm.tools.Logging;
    2829import org.openstreetmap.josm.tools.Utils;
    2930
     
    396397        // (This should almost never happen.)
    397398        if (java.lang.Double.isNaN(d)) {
    398             Main.error("NaN in greatCircleDistance");
     399            Logging.error("NaN in greatCircleDistance");
    399400            d = PI * WGS84.a;
    400401        }
  • trunk/src/org/openstreetmap/josm/data/gpx/WayPoint.java

    r12199 r12620  
    88import java.util.Objects;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.actions.search.SearchCompiler.Match;
    1211import org.openstreetmap.josm.data.coor.EastNorth;
     
    1413import org.openstreetmap.josm.data.coor.LatLon;
    1514import org.openstreetmap.josm.data.projection.Projecting;
     15import org.openstreetmap.josm.tools.Logging;
    1616import org.openstreetmap.josm.tools.UncheckedParseException;
    1717import org.openstreetmap.josm.tools.date.DateUtils;
     
    157157                return time;
    158158            } catch (UncheckedParseException e) {
    159                 Main.warn(e);
     159                Logging.warn(e);
    160160                time = 0;
    161161            }
  • trunk/src/org/openstreetmap/josm/data/imagery/CachedAttributionBingAerialTileSource.java

    r11510 r12620  
    1212import org.openstreetmap.gui.jmapviewer.tilesources.BingAerialTileSource;
    1313import org.openstreetmap.gui.jmapviewer.tilesources.TileSourceInfo;
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.gui.util.GuiHelper;
    1615import org.openstreetmap.josm.io.CacheCustomContent;
    1716import org.openstreetmap.josm.io.OnlineResource;
    1817import org.openstreetmap.josm.tools.HttpClient;
     18import org.openstreetmap.josm.tools.Logging;
    1919import org.xml.sax.InputSource;
    2020
     
    5757            URL u = getAttributionUrl();
    5858            final String r = HttpClient.create(u).connect().fetchContent();
    59             Main.info("Successfully loaded Bing attribution data.");
     59            Logging.info("Successfully loaded Bing attribution data.");
    6060            return r.getBytes("UTF-8");
    6161        }
     
    6767                OnlineResource.ALL.checkOfflineAccess(attributionUrl, attributionUrl);
    6868            } catch (MalformedURLException e) {
    69                 Main.error(e);
     69                Logging.error(e);
    7070            }
    7171        }
     
    8787                    return ret;
    8888                } catch (IOException ex) {
    89                     Main.warn(ex, "Could not connect to Bing API. Will retry in " + waitTimeSec + " seconds.");
     89                    Logging.log(Logging.LEVEL_WARN, "Could not connect to Bing API. Will retry in " + waitTimeSec + " seconds.", ex);
    9090                    Thread.sleep(TimeUnit.SECONDS.toMillis(waitTimeSec));
    9191                    waitTimeSec *= 2;
  • trunk/src/org/openstreetmap/josm/data/imagery/CachedTileLoaderFactory.java

    r11288 r12620  
    1616import org.openstreetmap.josm.data.preferences.StringProperty;
    1717import org.openstreetmap.josm.tools.CheckParameterUtil;
     18import org.openstreetmap.josm.tools.Logging;
    1819
    1920/**
     
    4748                    Map.class);
    4849        } catch (NoSuchMethodException | SecurityException e) {
    49             Main.warn(e);
     50            Logging.warn(e);
    5051            throw new IllegalArgumentException(e);
    5152        }
     
    5758            defPath = new File(Main.pref.getCacheDirectory(), "tiles").getAbsolutePath();
    5859        } catch (SecurityException e) {
    59             Main.warn(e);
     60            Logging.warn(e);
    6061        }
    6162        return new StringProperty("imagery.generic.loader.cachedir", defPath);
     
    8687                    headers);
    8788        } catch (IllegalArgumentException e) {
    88             Main.warn(e);
     89            Logging.warn(e);
    8990            throw e;
    9091        } catch (ReflectiveOperationException e) {
    91             Main.warn(e);
     92            Logging.warn(e);
    9293            throw new IllegalArgumentException(e);
    9394        }
  • trunk/src/org/openstreetmap/josm/data/imagery/ImageryInfo.java

    r12445 r12620  
    3434import org.openstreetmap.josm.tools.ImageProvider;
    3535import org.openstreetmap.josm.tools.LanguageInfo;
     36import org.openstreetmap.josm.tools.Logging;
    3637import org.openstreetmap.josm.tools.MultiMap;
    3738import org.openstreetmap.josm.tools.Utils;
     
    421422                    }
    422423                } catch (IllegalArgumentException ex) {
    423                     Main.warn(ex);
     424                    Logging.warn(ex);
    424425                }
    425426            }
  • trunk/src/org/openstreetmap/josm/data/imagery/ImageryLayerInfo.java

    r11707 r12620  
    2424import org.openstreetmap.josm.io.OnlineResource;
    2525import org.openstreetmap.josm.io.imagery.ImageryReader;
     26import org.openstreetmap.josm.tools.Logging;
    2627import org.openstreetmap.josm.tools.Utils;
    2728import org.xml.sax.SAXException;
     
    8283                    add(i);
    8384                } catch (IllegalArgumentException e) {
    84                     Main.warn("Unable to load imagery preference entry:"+e);
     85                    Logging.warn("Unable to load imagery preference entry:"+e);
    8586                }
    8687            }
     
    150151                OnlineResource.JOSM_WEBSITE.checkOfflineAccess(source, Main.getJOSMWebsite());
    151152            } catch (OfflineAccessException e) {
    152                 Main.warn(e, false);
     153                Logging.log(Logging.LEVEL_WARN, e);
    153154                online = false;
    154155            }
     
    163164            } catch (IOException ex) {
    164165                loadError = true;
    165                 Main.error(ex, false);
     166                Logging.log(Logging.LEVEL_ERROR, ex);
    166167            } catch (SAXException ex) {
    167168                loadError = true;
    168                 Main.error(ex);
     169                Logging.error(ex);
    169170            }
    170171        }
     
    205206                if (idMap.containsKey(i.getId())) {
    206207                    notUnique.add(i.getId());
    207                     Main.error("Id ''{0}'' is not unique - used by ''{1}'' and ''{2}''!",
     208                    Logging.error("Id ''{0}'' is not unique - used by ''{1}'' and ''{2}''!",
    208209                            i.getId(), i.getName(), idMap.get(i.getId()).getName());
    209210                    continue;
     
    256257                        }
    257258                    } else {
    258                         Main.error("Default imagery ''{0}'' has no id. Skipping.", def.getName());
     259                        Logging.error("Default imagery ''{0}'' has no id. Skipping.", def.getName());
    259260                    }
    260261                }
     
    279280            if (matchingDefault != null && !matchingDefault.equalsPref(info)) {
    280281                layers.set(i, matchingDefault);
    281                 Main.info(tr("Update imagery ''{0}''", info.getName()));
     282                Logging.info(tr("Update imagery ''{0}''", info.getName()));
    282283                changed = true;
    283284            }
     
    300301                remove(info.getValue());
    301302                drop.add(info.getKey());
    302                 Main.info(tr("Drop old imagery ''{0}''", info.getValue().getName()));
     303                Logging.info(tr("Drop old imagery ''{0}''", info.getValue().getName()));
    303304            }
    304305        }
  • trunk/src/org/openstreetmap/josm/data/imagery/OffsetBookmark.java

    r12163 r12620  
    2121import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
    2222import org.openstreetmap.josm.gui.layer.ImageryLayer;
     23import org.openstreetmap.josm.tools.Logging;
    2324
    2425/**
     
    7879        }
    7980        if (projection_code == null) {
    80             Main.error(tr("Projection ''{0}'' is not found, bookmark ''{1}'' is not usable", projection_code, name));
     81            Logging.error(tr("Projection ''{0}'' is not found, bookmark ''{1}'' is not usable", projection_code, name));
    8182        }
    8283    }
  • trunk/src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

    r12542 r12620  
    2727import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
    2828import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
    29 import org.openstreetmap.josm.Main;
    3029import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
    3130import org.openstreetmap.josm.data.cache.CacheEntry;
     
    3534import org.openstreetmap.josm.data.preferences.LongProperty;
    3635import org.openstreetmap.josm.tools.HttpClient;
     36import org.openstreetmap.josm.tools.Logging;
    3737
    3838/**
     
    124124            } catch (IOException e) {
    125125                LOG.log(Level.WARNING, "JCS TMS - error loading from cache for tile {0}: {1}", new Object[] {tile.getKey(), e.getMessage()});
    126                 Main.warn(e);
     126                Logging.warn(e);
    127127            }
    128128        }
     
    152152        } catch (IOException | IllegalArgumentException e) {
    153153            // if we fail to submit the job, mark tile as loaded and set error message
    154             Main.warn(e, false);
     154            Logging.log(Logging.LEVEL_WARN, e);
    155155            tile.finishLoading();
    156156            tile.setError(e.getMessage());
  • trunk/src/org/openstreetmap/josm/data/imagery/WMTSTileSource.java

    r12550 r12620  
    5858import org.openstreetmap.josm.tools.CheckParameterUtil;
    5959import org.openstreetmap.josm.tools.GBC;
     60import org.openstreetmap.josm.tools.Logging;
    6061import org.openstreetmap.josm.tools.Utils;
    6162
     
    293294        this.layers = getCapabilities();
    294295        if (info.getDefaultLayers().isEmpty()) {
    295             Main.warn(tr("No default layer selected, choosing first layer."));
     296            Logging.warn(tr("No default layer selected, choosing first layer."));
    296297            if (!layers.isEmpty()) {
    297298                Layer first = layers.iterator().next();
     
    383384            } catch (XMLStreamException e) {
    384385                cf.clear();
    385                 Main.warn(new String(data, StandardCharsets.UTF_8));
     386                Logging.warn(new String(data, StandardCharsets.UTF_8));
    386387                throw new IllegalArgumentException(e);
    387388            }
     
    491492        if (layer.format == null) {
    492493            // no format found - it's mandatory parameter - can't use this layer
    493             Main.warn(tr("Can''t use layer {0} because no supported formats where found. Layer is available in formats: {1}",
     494            Logging.warn(tr("Can''t use layer {0} because no supported formats where found. Layer is available in formats: {1}",
    494495                    layer.getUserTitle(),
    495496                    String.join(", ", unsupportedFormats)));
     
    725726        }
    726727        // if no layers is found, fallback to default mercator tile size. Maybe it will work
    727         Main.warn("WMTS: Could not determine tile size. Using default tile size of: {0}", getDefaultTileSize());
     728        Logging.warn("WMTS: Could not determine tile size. Using default tile size of: {0}", getDefaultTileSize());
    728729        return getDefaultTileSize();
    729730    }
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r12542 r12620  
    5555import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionManager;
    5656import org.openstreetmap.josm.tools.ListenerList;
     57import org.openstreetmap.josm.tools.Logging;
    5758import org.openstreetmap.josm.tools.SubclassFilteredCollection;
    5859
     
    10101011        OsmPrimitive result = getPrimitiveById(primitiveId);
    10111012        if (result == null && primitiveId != null) {
    1012             Main.warn(tr("JOSM expected to find primitive [{0} {1}] in dataset but it is not there. Please report this "
     1013            Logging.warn(tr("JOSM expected to find primitive [{0} {1}] in dataset but it is not there. Please report this "
    10131014                    + "at {2}. This is not a critical error, it should be safe to continue in your work.",
    10141015                    primitiveId.getType(), Long.toString(primitiveId.getUniqueId()), Main.getJOSMWebsite()));
    1015             Main.error(new Exception());
     1016            Logging.error(new Exception());
    10161017        }
    10171018
  • trunk/src/org/openstreetmap/josm/data/osm/DatasetConsistencyTest.java

    r11746 r12620  
    88import java.io.Writer;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.tools.JosmRuntimeException;
     11import org.openstreetmap.josm.tools.Logging;
    1212import org.openstreetmap.josm.tools.Utils;
    1313
     
    186186
    187187    private void printElapsedTime(long startTime) {
    188         if (Main.isDebugEnabled()) {
     188        if (Logging.isDebugEnabled()) {
    189189            StackTraceElement item = Thread.currentThread().getStackTrace()[2];
    190190            String operation = getClass().getSimpleName() + '.' + item.getMethodName();
    191191            long elapsedTime = System.currentTimeMillis() - startTime;
    192             Main.debug(tr("Test ''{0}'' completed in {1}",
     192            Logging.debug(tr("Test ''{0}'' completed in {1}",
    193193                    operation, Utils.getDurationString(elapsedTime)));
    194194        }
     
    216216            writer.println("Exception during dataset integrity test:");
    217217            e.printStackTrace(writer);
    218             Main.warn(e);
     218            Logging.warn(e);
    219219        }
    220220    }
  • trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java

    r12414 r12620  
    2121import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2222import org.openstreetmap.josm.gui.widgets.OSDLabel;
     23import org.openstreetmap.josm.tools.Logging;
    2324import org.openstreetmap.josm.tools.Utils;
    2425
     
    5152                filterMatcher.add(filter);
    5253            } catch (ParseError e) {
    53                 Main.error(e);
     54                Logging.error(e);
    5455                JOptionPane.showMessageDialog(
    5556                        Main.parent,
  • trunk/src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java

    r11119 r12620  
    2323import java.util.stream.Collectors;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.tools.CheckParameterUtil;
    2726import org.openstreetmap.josm.tools.Geometry;
    2827import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.MultiMap;
    3030import org.openstreetmap.josm.tools.Pair;
     
    203203            return makeFromPolygons(joinedWays);
    204204        } catch (JoinedPolygonCreationException ex) {
    205             Main.debug(ex);
     205            Logging.debug(ex);
    206206            return ex.getMessage();
    207207        }
  • trunk/src/org/openstreetmap/josm/data/osm/NoteData.java

    r12540 r12620  
    1717import org.openstreetmap.josm.gui.JosmUserIdentityManager;
    1818import org.openstreetmap.josm.tools.ListenerList;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    137138                } else {
    138139                    // TODO merge comments?
    139                     Main.info("Keeping existing note id={0} with uncommitted changes", String.valueOf(newNote.getId()));
     140                    Logging.info("Keeping existing note id={0} with uncommitted changes", String.valueOf(newNote.getId()));
    140141                }
    141142            }
     
    162163        NoteComment comment = new NoteComment(new Date(), getCurrentUser(), text, NoteComment.Action.OPENED, true);
    163164        note.addComment(comment);
    164         if (Main.isDebugEnabled()) {
    165             Main.debug("Created note {0} with comment: {1}", note.getId(), text);
     165        if (Logging.isDebugEnabled()) {
     166            Logging.debug("Created note {0} with comment: {1}", note.getId(), text);
    166167        }
    167168        noteList.add(note);
     
    181182            throw new IllegalStateException("Cannot add a comment to a closed note");
    182183        }
    183         if (Main.isDebugEnabled()) {
    184             Main.debug("Adding comment to note {0}: {1}", note.getId(), text);
     184        if (Logging.isDebugEnabled()) {
     185            Logging.debug("Adding comment to note {0}: {1}", note.getId(), text);
    185186        }
    186187        NoteComment comment = new NoteComment(new Date(), getCurrentUser(), text, NoteComment.Action.COMMENTED, true);
     
    201202            throw new IllegalStateException("Cannot close a note that isn't open");
    202203        }
    203         if (Main.isDebugEnabled()) {
    204             Main.debug("closing note {0} with comment: {1}", note.getId(), text);
     204        if (Logging.isDebugEnabled()) {
     205            Logging.debug("closing note {0} with comment: {1}", note.getId(), text);
    205206        }
    206207        NoteComment comment = new NoteComment(new Date(), getCurrentUser(), text, NoteComment.Action.CLOSED, true);
     
    223224            throw new IllegalStateException("Cannot reopen a note that isn't closed");
    224225        }
    225         if (Main.isDebugEnabled()) {
    226             Main.debug("reopening note {0} with comment: {1}", note.getId(), text);
    227         }
     226        Logging.debug("reopening note {0} with comment: {1}", note.getId(), text);
    228227        NoteComment comment = new NoteComment(new Date(), getCurrentUser(), text, NoteComment.Action.REOPENED, true);
    229228        note.addComment(comment);
  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r12190 r12620  
    2727import org.openstreetmap.josm.gui.mappaint.StyleCache;
    2828import org.openstreetmap.josm.tools.CheckParameterUtil;
     29import org.openstreetmap.josm.tools.Logging;
    2930import org.openstreetmap.josm.tools.Utils;
    3031import org.openstreetmap.josm.tools.template_engine.TemplateEngineDataProvider;
     
    761762            return SearchCompiler.compile(Main.pref.get(prefName, defaultValue));
    762763        } catch (ParseError e) {
    763             Main.error(e, "Unable to compile pattern for " + prefName + ", trying default pattern:");
     764            Logging.log(Logging.LEVEL_ERROR, "Unable to compile pattern for " + prefName + ", trying default pattern:", e);
    764765        }
    765766
  • trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java

    r12537 r12620  
    1010import java.util.NoSuchElementException;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.coor.LatLon;
    1413import org.openstreetmap.josm.data.coor.QuadTiling;
     14import org.openstreetmap.josm.tools.Logging;
    1515
    1616/**
     
    598598        if (searchCache == null) {
    599599            searchCache = root;
    600             Main.info("bbox: " + searchBbox + " is out of the world");
     600            Logging.info("bbox: " + searchBbox + " is out of the world");
    601601        }
    602602
  • trunk/src/org/openstreetmap/josm/data/osm/TagCollection.java

    r12549 r12620  
    2222import java.util.stream.Stream;
    2323
    24 import org.openstreetmap.josm.Main;
     24import org.openstreetmap.josm.tools.Logging;
    2525import org.openstreetmap.josm.tools.Utils;
    2626
     
    725725                result += Integer.parseInt(value);
    726726            } catch (NumberFormatException e) {
    727                 Main.trace(e);
     727                Logging.trace(e);
    728728            }
    729729        }
  • trunk/src/org/openstreetmap/josm/data/osm/history/HistoryOsmPrimitive.java

    r11878 r12620  
    1313import java.util.Objects;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.Changeset;
    1716import org.openstreetmap.josm.data.osm.Node;
     
    2625import org.openstreetmap.josm.data.osm.Way;
    2726import org.openstreetmap.josm.tools.CheckParameterUtil;
     27import org.openstreetmap.josm.tools.Logging;
    2828import org.openstreetmap.josm.tools.date.DateUtils;
    2929
     
    354354            data.setVisible(visible);
    355355        } catch (IllegalStateException e) {
    356             Main.error(e, "Cannot change visibility for "+data+':');
     356            Logging.log(Logging.LEVEL_ERROR, "Cannot change visibility for "+data+':', e);
    357357        }
    358358        data.setTimestamp(timestamp);
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/AbstractMapRenderer.java

    r11992 r12620  
    2020import org.openstreetmap.josm.gui.NavigatableComponent;
    2121import org.openstreetmap.josm.tools.CheckParameterUtil;
     22import org.openstreetmap.josm.tools.Logging;
    2223
    2324/**
     
    157158            // On read, it would first check, if the way still has firstIdx+2 nodes, then check if the corresponding way nodes are still
    158159            // the same and report changes in a more controlled manner.
    159             Main.trace(e);
     160            Logging.trace(e);
    160161        }
    161162    }
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java

    r12279 r12620  
    1717import org.openstreetmap.josm.plugins.PluginHandler;
    1818import org.openstreetmap.josm.tools.CheckParameterUtil;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    138139                return Class.forName(className, true, cl);
    139140            } catch (final NoClassDefFoundError | ClassNotFoundException e) {
    140                 Main.trace(e);
     141                Logging.trace(e);
    141142            }
    142143        }
    143         Main.error(tr("Failed to load map renderer class ''{0}''. The class wasn''t found.", className));
     144        Logging.error(tr("Failed to load map renderer class ''{0}''. The class wasn''t found.", className));
    144145        return null;
    145146    }
     
    161162        Class<?> c = loadRendererClass(rendererClassName);
    162163        if (c == null) {
    163             Main.error(tr("Can''t activate map renderer class ''{0}'', because the class wasn''t found.", rendererClassName));
    164             Main.error(tr("Activating the standard map renderer instead."));
     164            Logging.error(tr("Can''t activate map renderer class ''{0}'', because the class wasn''t found.", rendererClassName));
     165            Logging.error(tr("Activating the standard map renderer instead."));
    165166            activateDefault();
    166167        } else if (!AbstractMapRenderer.class.isAssignableFrom(c)) {
    167             Main.error(tr("Can''t activate map renderer class ''{0}'', because it isn''t a subclass of ''{1}''.",
     168            Logging.error(tr("Can''t activate map renderer class ''{0}'', because it isn''t a subclass of ''{1}''.",
    168169                    rendererClassName, AbstractMapRenderer.class.getName()));
    169             Main.error(tr("Activating the standard map renderer instead."));
     170            Logging.error(tr("Activating the standard map renderer instead."));
    170171            activateDefault();
    171172        } else {
    172173            Class<? extends AbstractMapRenderer> renderer = c.asSubclass(AbstractMapRenderer.class);
    173174            if (!isRegistered(renderer)) {
    174                 Main.error(tr("Can''t activate map renderer class ''{0}'', because it isn''t registered as map renderer.", rendererClassName));
    175                 Main.error(tr("Activating the standard map renderer instead."));
     175                Logging.error(tr("Can''t activate map renderer class ''{0}'', because it isn''t registered as map renderer.",
     176                        rendererClassName));
     177                Logging.error(tr("Activating the standard map renderer instead."));
    176178                activateDefault();
    177179            } else {
     
    306308            return AbstractMapRenderer.class.cast(c.newInstance(g, viewport, isInactiveMode));
    307309        } catch (InvocationTargetException e) {
    308             Main.debug(e);
     310            Logging.debug(e);
    309311            throw new MapRendererFactoryException(e.getCause());
    310312        } catch (ReflectiveOperationException | IllegalArgumentException e) {
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/RenderBenchmarkCollector.java

    r11726 r12620  
    99import org.openstreetmap.josm.data.osm.visitor.paint.StyledMapRenderer.StyleRecord;
    1010import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
     11import org.openstreetmap.josm.tools.Logging;
    1112import org.openstreetmap.josm.tools.Utils;
    1213
     
    147148     */
    148149    public static Supplier<RenderBenchmarkCollector> defaultBenchmarkSupplier() {
    149         return () -> Main.isTraceEnabled() || Main.pref.getBoolean("mappaint.render.benchmark", false)
     150        return () -> Logging.isTraceEnabled() || Main.pref.getBoolean("mappaint.render.benchmark", false)
    150151                ? new LoggingBenchmark() : new RenderBenchmarkCollector();
    151152    }
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java

    r12539 r12620  
    241241            gv.setGlyphTransform(0, AffineTransform.getTranslateInstance(1000, 1000));
    242242            Shape shape = gv.getGlyphOutline(0);
    243             if (Main.isTraceEnabled()) {
    244                 Main.trace("#10446: shape: "+shape.getBounds());
     243            if (Logging.isTraceEnabled()) {
     244                Logging.trace("#10446: shape: {0}", shape.getBounds());
    245245            }
    246246            // x is about 1000 on normal stystems and about 2000 when the bug occurs
     
    11291129                                (p1, p2) -> p1.append(p2, false)),
    11301130                        osm.isDisabled(), text);
    1131             } else if (Main.isTraceEnabled()) {
    1132                 Main.trace("Couldn't find a correct label placement for " + osm + " / " + name);
     1131            } else {
     1132                Logging.trace("Couldn't find a correct label placement for {0} / {1}", osm, name);
    11331133            }
    11341134        });
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/relations/Multipolygon.java

    r12189 r12620  
    3030import org.openstreetmap.josm.tools.Geometry;
    3131import org.openstreetmap.josm.tools.Geometry.AreaAndPerimeter;
     32import org.openstreetmap.josm.tools.Logging;
    3233
    3334/**
     
    405406                if (ds == null) {
    406407                    // DataSet still not found. This should not happen, but a warning does no harm
    407                     Main.warn("DataSet not found while resetting nodes in Multipolygon. " +
     408                    Logging.warn("DataSet not found while resetting nodes in Multipolygon. " +
    408409                            "This should not happen, you may report it to JOSM developers.");
    409410                } else if (wayIds.size() == 1) {
  • trunk/src/org/openstreetmap/josm/data/preferences/AbstractToStringProperty.java

    r12196 r12620  
    22package org.openstreetmap.josm.data.preferences;
    33
    4 import org.openstreetmap.josm.Main;
    54import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    65import org.openstreetmap.josm.tools.CheckParameterUtil;
     6import org.openstreetmap.josm.tools.Logging;
    77import org.openstreetmap.josm.tools.bugreport.BugReport;
    88
     
    8989                return fromString(string);
    9090            } catch (InvalidPreferenceValueException e) {
    91                 Main.warn(BugReport.intercept(e).put("key", key).put("value", string));
     91                Logging.warn(BugReport.intercept(e).put("key", key).put("value", string));
    9292            }
    9393        }
  • trunk/src/org/openstreetmap/josm/data/preferences/ParametrizedEnumProperty.java

    r12453 r12620  
    33
    44import org.openstreetmap.josm.Main;
     5import org.openstreetmap.josm.tools.Logging;
    56
    67/**
     
    3334            return Enum.valueOf(enumClass, s);
    3435        } catch (IllegalArgumentException e) {
    35             Main.trace(e);
     36            Logging.trace(e);
    3637            return defaultValue;
    3738        }
  • trunk/src/org/openstreetmap/josm/data/preferences/PreferencesReader.java

    r11553 r12620  
    3030import javax.xml.validation.Validator;
    3131
    32 import org.openstreetmap.josm.Main;
    3332import org.openstreetmap.josm.io.CachedFile;
    3433import org.openstreetmap.josm.io.XmlStreamParsingException;
     34import org.openstreetmap.josm.tools.Logging;
    3535import org.xml.sax.SAXException;
    3636
     
    146146                    version = Integer.parseInt(parser.getAttributeValue(null, "version"));
    147147                } catch (NumberFormatException e) {
    148                     if (Main.isDebugEnabled()) {
    149                         Main.debug(e.getMessage());
    150                     }
     148                    Logging.log(Logging.LEVEL_DEBUG, e);
    151149                }
    152150                parseRoot();
  • trunk/src/org/openstreetmap/josm/data/preferences/StrokeProperty.java

    r10874 r12620  
    88import java.util.stream.Collectors;
    99
    10 import org.openstreetmap.josm.Main;
     10import org.openstreetmap.josm.tools.Logging;
    1111
    1212/**
     
    7878
    7979            if (sumAbs < 1e-1) {
    80                 Main.error("Error in stroke dash format (all zeros): " + code);
     80                Logging.error("Error in stroke dash format (all zeros): " + code);
    8181                dashes = Collections.emptyList();
    8282            }
  • trunk/src/org/openstreetmap/josm/data/projection/CustomProjection.java

    r12295 r12620  
    1515import java.util.regex.Pattern;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.data.Bounds;
    1918import org.openstreetmap.josm.data.ProjectionBounds;
     
    3332import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    3433import org.openstreetmap.josm.tools.JosmRuntimeException;
     34import org.openstreetmap.josm.tools.Logging;
    3535import org.openstreetmap.josm.tools.Utils;
    3636import org.openstreetmap.josm.tools.bugreport.BugReport;
     
    231231            update(pref);
    232232        } catch (ProjectionConfigurationException ex) {
    233             Main.trace(ex);
     233            Logging.trace(ex);
    234234            try {
    235235                update(null);
     
    701701                return Integer.valueOf(code.substring(5));
    702702            } catch (NumberFormatException e) {
    703                 Main.warn(e);
     703                Logging.warn(e);
    704704            }
    705705        }
     
    858858                    }
    859859                } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    860                     Main.error(e);
     860                    Logging.error(e);
    861861                }
    862862            }
  • trunk/src/org/openstreetmap/josm/data/projection/Projections.java

    r12294 r12620  
    4545import org.openstreetmap.josm.io.CachedFile;
    4646import org.openstreetmap.josm.tools.JosmRuntimeException;
     47import org.openstreetmap.josm.tools.Logging;
    4748import org.openstreetmap.josm.tools.Utils;
    4849
     
    181182                }
    182183            } catch (ProjectionConfigurationException e) {
    183                 Main.trace(e);
     184                Logging.trace(e);
    184185            }
    185186        }
     
    316317                    result.add(new ProjectionDefinition(code, name, definition));
    317318                } else {
    318                     Main.warn("Failed to parse line from the EPSG projection definition: "+line);
     319                    Logging.warn("Failed to parse line from the EPSG projection definition: "+line);
    319320                }
    320321            }
     
    339340                proj = pc.getProjection();
    340341            } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    341                 Main.warn(e, "Unable to get projection "+code+" with "+pc+':');
     342                Logging.log(Logging.LEVEL_WARN, "Unable to get projection "+code+" with "+pc+':', e);
    342343            }
    343344        }
  • trunk/src/org/openstreetmap/josm/data/projection/datum/NTV2GridShiftFile.java

    r11747 r12620  
    2929import java.util.Map;
    3030
    31 import org.openstreetmap.josm.Main;
     31import org.openstreetmap.josm.tools.Logging;
    3232
    3333/**
     
    8585    private static void readBytes(InputStream in, byte[] b) throws IOException {
    8686        if (in.read(b) < b.length) {
    87             Main.error("Failed to read expected amount of bytes ("+ b.length +") from stream");
     87            Logging.error("Failed to read expected amount of bytes ("+ b.length +") from stream");
    8888        }
    8989    }
  • trunk/src/org/openstreetmap/josm/data/projection/datum/NTV2SubGrid.java

    r11747 r12620  
    2525import java.nio.charset.StandardCharsets;
    2626
    27 import org.openstreetmap.josm.Main;
     27import org.openstreetmap.josm.tools.Logging;
    2828import org.openstreetmap.josm.tools.Utils;
    2929
     
    152152    private static void readBytes(InputStream in, byte[] b) throws IOException {
    153153        if (in.read(b) < b.length) {
    154             Main.error("Failed to read expected amount of bytes ("+ b.length +") from stream");
     154            Logging.error("Failed to read expected amount of bytes ("+ b.length +") from stream");
    155155        }
    156156    }
  • trunk/src/org/openstreetmap/josm/data/validation/OsmValidator.java

    r12542 r12620  
    6161import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference;
    6262import org.openstreetmap.josm.gui.preferences.validator.ValidatorPreference;
     63import org.openstreetmap.josm.tools.Logging;
    6364import org.openstreetmap.josm.tools.Utils;
    6465
     
    143144            allTestsMap.put(testClass.getName(), testClass.getConstructor().newInstance());
    144145        } catch (ReflectiveOperationException e) {
    145             Main.error(e);
     146            Logging.error(e);
    146147        }
    147148    }
     
    189190                    ignoredErrors.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
    190191                } catch (final FileNotFoundException e) {
    191                     Main.debug(Main.getErrorMessage(e));
     192                    Logging.debug(Logging.getErrorMessage(e));
    192193                } catch (final IOException e) {
    193                     Main.error(e);
     194                    Logging.error(e);
    194195                }
    195196            }
     
    225226            }
    226227        } catch (IOException e) {
    227             Main.error(e);
     228            Logging.error(e);
    228229        }
    229230    }
     
    355356    public static synchronized void initializeTests() {
    356357        if (!testsInitialized) {
    357             Main.debug("Initializing validator tests");
     358            Logging.debug("Initializing validator tests");
    358359            final long startTime = System.currentTimeMillis();
    359360            initializeTests(getTests());
    360361            testsInitialized = true;
    361             if (Main.isDebugEnabled()) {
     362            if (Logging.isDebugEnabled()) {
    362363                final long elapsedTime = System.currentTimeMillis() - startTime;
    363                 Main.debug("Initializing validator tests completed in " + Utils.getDurationString(elapsedTime));
     364                Logging.debug("Initializing validator tests completed in {0}", Utils.getDurationString(elapsedTime));
    364365            }
    365366        }
     
    377378                }
    378379            } catch (Exception e) { // NOPMD
    379                 Main.error(e);
     380                Logging.error(e);
    380381                if (!GraphicsEnvironment.isHeadless()) {
    381382                    JOptionPane.showMessageDialog(Main.parent,
  • trunk/src/org/openstreetmap/josm/data/validation/Severity.java

    r12390 r12620  
    77import java.awt.Color;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.data.preferences.ColorProperty;
     10import org.openstreetmap.josm.tools.Logging;
    1111
    1212/** The error severity */
     
    4848    public static void getColors() {
    4949        for (Severity c : values()) {
    50             if (Main.isDebugEnabled()) {
    51                 Main.debug(c.toString());
    52             }
     50            Logging.debug("{0}", c);
    5351        }
    5452    }
  • trunk/src/org/openstreetmap/josm/data/validation/Test.java

    r11608 r12620  
    2727import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    2828import org.openstreetmap.josm.tools.GBC;
     29import org.openstreetmap.josm.tools.Logging;
    2930import org.openstreetmap.josm.tools.Utils;
    3031
     
    153154        String startMessage = tr("Running test {0}", name);
    154155        this.progressMonitor.beginTask(startMessage);
    155         Main.debug(startMessage);
     156        Logging.debug(startMessage);
    156157        this.errors = new ArrayList<>(30);
    157158        this.startTime = System.currentTimeMillis();
     
    187188            // fix #11567 where elapsedTime is < 0
    188189            long elapsedTime = Math.max(0, System.currentTimeMillis() - startTime);
    189             Main.debug(tr("Test ''{0}'' completed in {1}", getName(), Utils.getDurationString(elapsedTime)));
     190            Logging.debug(tr("Test ''{0}'' completed in {1}", getName(), Utils.getDurationString(elapsedTime)));
    190191        }
    191192    }
  • trunk/src/org/openstreetmap/josm/data/validation/routines/DomainValidator.java

    r12466 r12620  
    2121import java.util.Locale;
    2222
    23 import org.openstreetmap.josm.Main;
     23import org.openstreetmap.josm.tools.Logging;
    2424
    2525/**
     
    20522052            }
    20532053        } catch (IllegalArgumentException e) { // input is not valid
    2054             Main.trace(e);
     2054            Logging.trace(e);
    20552055            return input;
    20562056        }
  • trunk/src/org/openstreetmap/josm/data/validation/routines/UrlValidator.java

    r11893 r12620  
    2929import java.util.regex.Pattern;
    3030
    31 import org.openstreetmap.josm.Main;
     31import org.openstreetmap.josm.tools.Logging;
    3232
    3333/**
     
    450450            }
    451451        } catch (URISyntaxException e) {
    452             Main.trace(e);
     452            Logging.trace(e);
    453453            return false;
    454454        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/Addresses.java

    r12318 r12620  
    2626import org.openstreetmap.josm.data.validation.TestError;
    2727import org.openstreetmap.josm.tools.Geometry;
     28import org.openstreetmap.josm.tools.Logging;
    2829import org.openstreetmap.josm.tools.Pair;
    2930import org.openstreetmap.josm.tools.SubclassFilteredCollection;
     
    216217                    }
    217218                } else {
    218                     Main.warn("Addresses test skipped chunck "+chunk+" for street part "+streetPart+" because p1 or p2 is null");
     219                    Logging.warn("Addresses test skipped chunck "+chunk+" for street part "+streetPart+" because p1 or p2 is null");
    219220                }
    220221            }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java

    r12402 r12620  
    1313import java.util.regex.Pattern;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1716import org.openstreetmap.josm.data.validation.Severity;
     
    1918import org.openstreetmap.josm.data.validation.TestError;
    2019import org.openstreetmap.josm.tools.LanguageInfo;
     20import org.openstreetmap.josm.tools.Logging;
    2121import org.openstreetmap.josm.tools.SubclassFilteredCollection;
    2222
     
    207207            }
    208208        } catch (ConditionalParsingException ex) {
    209             Main.debug(ex);
     209            Logging.debug(ex);
    210210            return ex.getMessage();
    211211        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

    r11913 r12620  
    1111import java.util.Objects;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.coor.EastNorth;
    1514import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2322import org.openstreetmap.josm.data.validation.util.ValUtil;
    2423import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     24import org.openstreetmap.josm.tools.Logging;
    2525
    2626/**
     
    268268            final EastNorth en2 = es1.getSecondNode().getEastNorth();
    269269            if (en1 == null || en2 == null) {
    270                 Main.warn("Crossing ways test skipped "+es1);
     270                Logging.warn("Crossing ways test skipped "+es1);
    271271                continue;
    272272            }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/Lanes.java

    r12461 r12620  
    88import java.util.stream.Collectors;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1211import org.openstreetmap.josm.data.validation.Severity;
    1312import org.openstreetmap.josm.data.validation.Test;
    1413import org.openstreetmap.josm.data.validation.TestError;
     14import org.openstreetmap.josm.tools.Logging;
    1515import org.openstreetmap.josm.tools.Utils;
    1616
     
    6464                }
    6565            } catch (NumberFormatException ignore) {
    66                 Main.debug(ignore.getMessage());
     66                Logging.debug(ignore.getMessage());
    6767            }
    6868        }
     
    8282        }
    8383        } catch (NumberFormatException ignore) {
    84             Main.debug(ignore.getMessage());
     84            Logging.debug(ignore.getMessage());
    8585        }
    8686    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java

    r12410 r12620  
    22package org.openstreetmap.josm.data.validation.tests;
    33
     4import static org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.FixCommand.evaluateObject;
    45import static org.openstreetmap.josm.tools.I18n.tr;
    56
     
    6465import org.openstreetmap.josm.io.UTFInputStreamReader;
    6566import org.openstreetmap.josm.tools.CheckParameterUtil;
     67import org.openstreetmap.josm.tools.Logging;
    6668import org.openstreetmap.josm.tools.MultiMap;
    6769import org.openstreetmap.josm.tools.Utils;
     
    319321                                check.errors.put(ai, Severity.valueOf(ai.key.substring("throw".length()).toUpperCase(Locale.ENGLISH)));
    320322                            } catch (IllegalArgumentException e) {
    321                                 Main.warn(e, "Unsupported "+ai.key+" instruction. Allowed instructions are "+POSSIBLE_THROWS+'.');
     323                                Logging.log(Logging.LEVEL_WARN,
     324                                        "Unsupported "+ai.key+" instruction. Allowed instructions are "+POSSIBLE_THROWS+'.', e);
    322325                            }
    323326                        } else if ("fixAdd".equals(ai.key)) {
     
    388391                            new GroupedMapCSSRule(map.getValue(), map.getKey())));
    389392                } catch (IllegalDataException e) {
    390                     Main.error("Cannot add MapCss rule: "+e.getMessage());
     393                    Logging.error("Cannot add MapCss rule: "+e.getMessage());
    391394                    source.logError(e);
    392395                }
     
    452455                }
    453456            } catch (IndexOutOfBoundsException ignore) {
    454                 Main.debug(ignore);
     457                Logging.debug(ignore);
    455458            }
    456459            return null;
     
    480483                    m.appendReplacement(sb, String.valueOf(argument).replace("^(", "").replace(")$", ""));
    481484                } catch (IndexOutOfBoundsException | IllegalArgumentException e) {
    482                     Main.error(e, tr("Unable to replace argument {0} in {1}: {2}", argument, sb, e.getMessage()));
     485                    Logging.log(Logging.LEVEL_ERROR, tr("Unable to replace argument {0} in {1}: {2}", argument, sb, e.getMessage()), e);
    483486                }
    484487            }
     
    735738            if (Main.pref.getBoolean("validator.check_assert_local_rules", false) && Utils.isLocalUrl(url)) {
    736739                for (String msg : checkAsserts(result.parseChecks)) {
    737                     Main.warn(msg);
     740                    Logging.warn(msg);
    738741                }
    739742            }
     
    752755            try {
    753756                if (!i.startsWith("resource:")) {
    754                     Main.info(tr("Adding {0} to tag checker", i));
    755                 } else if (Main.isDebugEnabled()) {
    756                     Main.debug(tr("Adding {0} to tag checker", i));
     757                    Logging.info(tr("Adding {0} to tag checker", i));
     758                } else if (Logging.isDebugEnabled()) {
     759                    Logging.debug(tr("Adding {0} to tag checker", i));
    757760                }
    758761                addMapCSS(i);
     
    761764                }
    762765            } catch (IOException | IllegalStateException | IllegalArgumentException ex) {
    763                 Main.warn(tr("Failed to add {0} to tag checker", i));
    764                 Main.warn(ex, false);
     766                Logging.warn(tr("Failed to add {0} to tag checker", i));
     767                Logging.log(Logging.LEVEL_WARN, ex);
    765768            } catch (ParseException ex) {
    766                 Main.warn(tr("Failed to add {0} to tag checker", i));
    767                 Main.warn(ex);
     769                Logging.warn(tr("Failed to add {0} to tag checker", i));
     770                Logging.warn(ex);
    768771            }
    769772        }
     
    780783        final DataSet ds = new DataSet();
    781784        for (final TagCheck check : schecks) {
    782             if (Main.isDebugEnabled()) {
    783                 Main.debug("Check: "+check);
    784             }
     785            Logging.debug("Check: {0}", check);
    785786            for (final Map.Entry<String, Boolean> i : check.assertions.entrySet()) {
    786                 if (Main.isDebugEnabled()) {
    787                     Main.debug("- Assertion: "+i);
    788                 }
     787                Logging.debug("- Assertion: {0}", i);
    789788                final OsmPrimitive p = OsmUtils.createPrimitive(i.getKey());
    790789                // Build minimal ordered list of checks to run to test the assertion
     
    798797                ds.addPrimitive(p);
    799798                final Collection<TestError> pErrors = getErrorsForPrimitive(p, true, checksToRun);
    800                 if (Main.isDebugEnabled()) {
    801                     Main.debug("- Errors: "+pErrors);
    802                 }
     799                Logging.debug("- Errors: {0}", pErrors);
    803800                @SuppressWarnings({"EqualsBetweenInconvertibleTypes", "EqualsIncompatibleType"})
    804801                final boolean isError = pErrors.stream().anyMatch(e -> e.getTester().equals(check.rule));
  • trunk/src/org/openstreetmap/josm/data/validation/tests/MultipolygonTest.java

    r11893 r12620  
    1818import java.util.Set;
    1919
    20 import org.openstreetmap.josm.Main;
    2120import org.openstreetmap.josm.command.ChangeCommand;
    2221import org.openstreetmap.josm.command.Command;
     
    4140import org.openstreetmap.josm.tools.Geometry;
    4241import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
     42import org.openstreetmap.josm.tools.Logging;
    4343
    4444/**
     
    591591            final EastNorth en2 = es1.getSecondNode().getEastNorth();
    592592            if (en1 == null || en2 == null) {
    593                 Main.warn("Crossing ways test (MP) skipped " + es1);
     593                Logging.warn("Crossing ways test (MP) skipped " + es1);
    594594                continue;
    595595            }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/OpeningHourTest.java

    r11889 r12620  
    1515import javax.script.ScriptException;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.command.ChangePropertyCommand;
    1918import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2322import org.openstreetmap.josm.io.CachedFile;
    2423import org.openstreetmap.josm.tools.LanguageInfo;
     24import org.openstreetmap.josm.tools.Logging;
    2525
    2626/**
     
    7272            }
    7373        } else {
    74             Main.warn("Unable to initialize OpeningHourTest because no JavaScript engine has been found");
     74            Logging.warn("Unable to initialize OpeningHourTest because no JavaScript engine has been found");
    7575        }
    7676    }
     
    207207                prettifiedValue = (String) ((Invocable) ENGINE).invokeMethod(r, "prettifyValue");
    208208            } catch (ScriptException | NoSuchMethodException e) {
    209                 Main.warn(e);
     209                Logging.warn(e);
    210210            }
    211211            for (final Object i : getList(((Invocable) ENGINE).invokeMethod(r, "getErrors"))) {
     
    219219            }
    220220        } catch (ScriptException | NoSuchMethodException ex) {
    221             Main.error(ex);
     221            Logging.error(ex);
    222222        }
    223223        return errors;
  • trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java

    r12390 r12620  
    5151import org.openstreetmap.josm.io.CachedFile;
    5252import org.openstreetmap.josm.tools.GBC;
     53import org.openstreetmap.josm.tools.Logging;
    5354import org.openstreetmap.josm.tools.MultiMap;
    5455import org.openstreetmap.josm.tools.Utils;
     
    205206                            tagcheckerfile = true;
    206207                            if (!DEFAULT_SOURCES.contains(source)) {
    207                                 Main.info(tr("Adding {0} to tag checker", source));
     208                                Logging.info(tr("Adding {0} to tag checker", source));
    208209                            }
    209210                        } else
     
    211212                            ignorefile = true;
    212213                            if (!DEFAULT_SOURCES.contains(source)) {
    213                                 Main.info(tr("Adding {0} to ignore tags", source));
     214                                Logging.info(tr("Adding {0} to ignore tags", source));
    214215                            }
    215216                        }
     
    238239                        default:
    239240                            if (!key.startsWith(";")) {
    240                                 Main.warn("Unsupported TagChecker key: " + key);
     241                                Logging.warn("Unsupported TagChecker key: " + key);
    241242                            }
    242243                        }
     
    249250                                checkerData.add(d);
    250251                            } else {
    251                                 Main.error(tr("Invalid tagchecker line - {0}: {1}", err, line));
     252                                Logging.error(tr("Invalid tagchecker line - {0}: {1}", err, line));
    252253                            }
    253254                        }
     
    257258                        harmonizedKeys.put(harmonizeKey(line.substring(1)), okValue);
    258259                    } else {
    259                         Main.error(tr("Invalid spellcheck line: {0}", line));
     260                        Logging.error(tr("Invalid spellcheck line: {0}", line));
    260261                    }
    261262                    if (isFirstLine) {
    262263                        isFirstLine = false;
    263264                        if (!(tagcheckerfile || ignorefile) && !DEFAULT_SOURCES.contains(source)) {
    264                             Main.info(tr("Adding {0} to spellchecker", source));
     265                            Logging.info(tr("Adding {0} to spellchecker", source));
    265266                        }
    266267                    }
    267268                }
    268269            } catch (IOException e) {
    269                 Main.error(e);
     270                Logging.error(e);
    270271                errorSources.append(source).append('\n');
    271272            }
     
    828829                }
    829830            } catch (IllegalStateException e) {
    830                 Main.error(e);
     831                Logging.error(e);
    831832                description = null;
    832833            }
     
    871872                    data.add(new CheckerElement(exp));
    872873                } catch (IllegalStateException e) {
    873                     Main.trace(e);
     874                    Logging.trace(e);
    874875                    return tr("Illegal expression ''{0}''", exp);
    875876                } catch (PatternSyntaxException e) {
    876                     Main.trace(e);
     877                    Logging.trace(e);
    877878                    return tr("Illegal regular expression ''{0}''", exp);
    878879                }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/UnconnectedWays.java

    r11913 r12620  
    3333import org.openstreetmap.josm.gui.preferences.validator.ValidatorPreference;
    3434import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     35import org.openstreetmap.josm.tools.Logging;
    3536
    3637/**
     
    318319        public boolean nearby(Node n, double dist) {
    319320            if (w == null) {
    320                 Main.debug("way null");
     321                Logging.debug("way null");
    321322                return false;
    322323            }
Note: See TracChangeset for help on using the changeset viewer.