Ignore:
Timestamp:
2017-08-22T22:26:32+02:00 (2 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/io
Files:
57 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/io/AbstractReader.java

    r12065 r12620  
    1212import java.util.Map.Entry;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.data.osm.Changeset;
    1615import org.openstreetmap.josm.data.osm.DataSet;
     
    2524import org.openstreetmap.josm.data.osm.Way;
    2625import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     26import org.openstreetmap.josm.tools.Logging;
    2727
    2828/**
     
    105105                }
    106106                if (n.isDeleted()) {
    107                     Main.info(tr("Deleted node {0} is part of way {1}", id, w.getId()));
     107                    Logging.info(tr("Deleted node {0} is part of way {1}", id, w.getId()));
    108108                } else {
    109109                    wayNodes.add(n);
     
    112112            w.setNodes(wayNodes);
    113113            if (w.hasIncompleteNodes()) {
    114                 Main.info(tr("Way {0} with {1} nodes has incomplete nodes because at least one node was missing in the loaded data.",
     114                Logging.info(tr("Way {0} with {1} nodes has incomplete nodes because at least one node was missing in the loaded data.",
    115115                          externalWayId, w.getNodesCount()));
    116116            }
     
    176176                }
    177177                if (primitive.isDeleted()) {
    178                     Main.info(tr("Deleted member {0} is used by relation {1}", primitive.getId(), relation.getId()));
     178                    Logging.info(tr("Deleted member {0} is used by relation {1}", primitive.getId(), relation.getId()));
    179179                } else {
    180180                    relationMembers.add(new RelationMember(rm.getRole(), primitive));
  • trunk/src/org/openstreetmap/josm/io/BoundingBoxDownloader.java

    r11746 r12620  
    99import java.util.List;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.data.Bounds;
    1312import org.openstreetmap.josm.data.DataSource;
     
    1817import org.openstreetmap.josm.tools.CheckParameterUtil;
    1918import org.openstreetmap.josm.tools.JosmRuntimeException;
     19import org.openstreetmap.josm.tools.Logging;
    2020import org.xml.sax.SAXException;
    2121
     
    7575                    final OsmTransferCanceledException canceledException = new OsmTransferCanceledException("Operation canceled");
    7676                    canceledException.initCause(ex);
    77                     Main.warn(canceledException);
     77                    Logging.warn(canceledException);
    7878                }
    7979            }
  • trunk/src/org/openstreetmap/josm/io/CacheCustomContent.java

    r11879 r12620  
    1212
    1313import org.openstreetmap.josm.Main;
     14import org.openstreetmap.josm.tools.Logging;
    1415import org.openstreetmap.josm.tools.Utils;
    1516
     
    99100            return false;
    100101        } catch (OfflineAccessException e) {
    101             Main.trace(e);
     102            Logging.trace(e);
    102103            return true;
    103104        }
     
    187188            this.data = new byte[input.available()];
    188189            if (input.read(this.data) < this.data.length) {
    189                 Main.error("Failed to read expected contents from "+path);
     190                Logging.error("Failed to read expected contents from "+path);
    190191            }
    191192        } catch (IOException e) {
    192             Main.trace(e);
     193            Logging.trace(e);
    193194            if (!isOffline()) {
    194195                this.data = updateForce();
     
    205206            output.flush();
    206207        } catch (IOException e) {
    207             Main.error(e);
     208            Logging.error(e);
    208209        }
    209210    }
  • trunk/src/org/openstreetmap/josm/io/CachedFile.java

    r11856 r12620  
    2929import org.openstreetmap.josm.Main;
    3030import org.openstreetmap.josm.tools.HttpClient;
     31import org.openstreetmap.josm.tools.Logging;
    3132import org.openstreetmap.josm.tools.Pair;
    3233import org.openstreetmap.josm.tools.Utils;
     
    327328            file = getFile();
    328329        } catch (IOException ex) {
    329             Main.warn(ex, false);
     330            Logging.log(Logging.LEVEL_WARN, ex);
    330331        }
    331332        if (file == null)
     
    351352        } catch (IOException e) {
    352353            if (file.getName().endsWith(".zip")) {
    353                 Main.warn(e, tr("Failed to open file with extension ''{2}'' and namepart ''{3}'' in zip file ''{0}''. Exception was: {1}",
    354                         file.getName(), e.toString(), extension, namepart));
     354                Logging.log(Logging.LEVEL_WARN,
     355                        tr("Failed to open file with extension ''{2}'' and namepart ''{3}'' in zip file ''{0}''. Exception was: {1}",
     356                        file.getName(), e.toString(), extension, namepart), e);
    355357            }
    356358        }
     
    389391            }
    390392        } catch (MalformedURLException e) {
    391             Main.warn(e);
     393            Logging.warn(e);
    392394        }
    393395    }
     
    422424            checkOfflineAccess(urlStr);
    423425        } catch (OfflineAccessException e) {
    424             Main.trace(e);
     426            Logging.trace(e);
    425427            offline = true;
    426428        }
     
    471473            final HttpClient.Response con = activeConnection.connect();
    472474            if (ifModifiedSince != null && con.getResponseCode() == HttpURLConnection.HTTP_NOT_MODIFIED) {
    473                 if (Main.isDebugEnabled()) {
    474                     Main.debug("304 Not Modified ("+urlStr+')');
    475                 }
     475                Logging.debug("304 Not Modified ({0})", urlStr);
    476476                if (localFile == null)
    477477                    throw new AssertionError();
     
    491491                        Arrays.asList(Long.toString(System.currentTimeMillis()), localFile.toString()));
    492492            } else {
    493                 Main.warn(tr("Failed to rename file {0} to {1}.",
     493                Logging.warn(tr("Failed to rename file {0} to {1}.",
    494494                destDirFile.getPath(), localFile.getPath()));
    495495            }
    496496        } catch (IOException e) {
    497497            if (age >= maxAgeMillis && age < maxAgeMillis*2) {
    498                 Main.warn(tr("Failed to load {0}, use cached file and retry next time: {1}", urlStr, e));
     498                Logging.warn(tr("Failed to load {0}, use cached file and retry next time: {1}", urlStr, e));
    499499                return localFile;
    500500            } else {
  • trunk/src/org/openstreetmap/josm/io/Capabilities.java

    r12200 r12620  
    1313import javax.xml.parsers.ParserConfigurationException;
    1414
    15 import org.openstreetmap.josm.Main;
     15import org.openstreetmap.josm.tools.Logging;
    1616import org.openstreetmap.josm.tools.Utils;
    1717import org.xml.sax.Attributes;
     
    161161
    162162    private static void warnIllegalValue(String attr, String elem, Object val) {
    163         Main.warn(tr("Illegal value of attribute ''{0}'' of element ''{1}'' in server capabilities. Got ''{2}''", attr, elem, val));
     163        Logging.warn(tr("Illegal value of attribute ''{0}'' of element ''{1}'' in server capabilities. Got ''{2}''", attr, elem, val));
    164164    }
    165165
  • trunk/src/org/openstreetmap/josm/io/CertificateAmendment.java

    r12241 r12620  
    2929
    3030import org.openstreetmap.josm.Main;
     31import org.openstreetmap.josm.tools.Logging;
    3132import org.openstreetmap.josm.tools.Utils;
    3233
     
    144145            }
    145146        } catch (KeyStoreException | NoSuchAlgorithmException | CertificateException | IOException | IllegalStateException e) {
    146             Main.error(e);
     147            Logging.error(e);
    147148        }
    148149
     
    166167            }
    167168            if (certificateIsMissing(keyStore, cert)) {
    168                 if (Main.isDebugEnabled()) {
    169                     Main.debug(tr("Adding certificate for TLS connections: {0}", cert.getSubjectX500Principal().getName()));
     169                if (Logging.isDebugEnabled()) {
     170                    Logging.debug(tr("Adding certificate for TLS connections: {0}", cert.getSubjectX500Principal().getName()));
    170171                }
    171172                String alias = "josm:" + new File(certAmend.id).getName();
  • trunk/src/org/openstreetmap/josm/io/ChangesetClosedException.java

    r11878 r12620  
    99import java.util.regex.Pattern;
    1010
    11 import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.tools.Logging;
    1212import org.openstreetmap.josm.tools.date.DateUtils;
    1313
     
    7878                closedOn = DateUtils.newOsmApiDateTimeFormat().parse(m.group(2));
    7979            } catch (ParseException ex) {
    80                 Main.error(tr("Failed to parse date ''{0}'' replied by server.", m.group(2)));
    81                 Main.error(ex);
     80                Logging.error(tr("Failed to parse date ''{0}'' replied by server.", m.group(2)));
     81                Logging.error(ex);
    8282            }
    8383        } else {
    84             Main.error(tr("Unexpected format of error header for conflict in changeset update. Got ''{0}''", errorHeader));
     84            Logging.error(tr("Unexpected format of error header for conflict in changeset update. Got ''{0}''", errorHeader));
    8585        }
    8686    }
  • trunk/src/org/openstreetmap/josm/io/ChangesetQuery.java

    r12495 r12620  
    1616import java.util.stream.Stream;
    1717
    18 import org.openstreetmap.josm.Main;
    1918import org.openstreetmap.josm.data.Bounds;
    2019import org.openstreetmap.josm.data.coor.LatLon;
    2120import org.openstreetmap.josm.gui.JosmUserIdentityManager;
    2221import org.openstreetmap.josm.tools.CheckParameterUtil;
     22import org.openstreetmap.josm.tools.Logging;
    2323import org.openstreetmap.josm.tools.Utils;
    2424import org.openstreetmap.josm.tools.date.DateUtils;
     
    267267        CheckParameterUtil.ensureParameterNotNull(changesetIds, "changesetIds");
    268268        if (changesetIds.size() > MAX_CHANGESETS_NUMBER) {
    269             Main.warn("Changeset query built with more than " + MAX_CHANGESETS_NUMBER + " changeset ids (" + changesetIds.size() + ')');
     269            Logging.warn("Changeset query built with more than " + MAX_CHANGESETS_NUMBER + " changeset ids (" + changesetIds.size() + ')');
    270270        }
    271271        this.changesetIds = changesetIds;
     
    471471                        break;
    472472                    default:
    473                         Main.warn("Unable to parse time: " + entry.getValue());
     473                        Logging.warn("Unable to parse time: " + entry.getValue());
    474474                    }
    475475                    break;
  • trunk/src/org/openstreetmap/josm/io/DefaultProxySelector.java

    r12537 r12620  
    2121import org.openstreetmap.josm.gui.preferences.server.ProxyPreferencesPanel;
    2222import org.openstreetmap.josm.gui.preferences.server.ProxyPreferencesPanel.ProxyPolicy;
     23import org.openstreetmap.josm.tools.Logging;
    2324
    2425/**
     
    9394            port = Integer.parseInt(value);
    9495        } catch (NumberFormatException e) {
    95             Main.error(tr("Unexpected format for port number in preference ''{0}''. Got ''{1}''.", property, value));
    96             Main.error(tr("The proxy will not be used."));
     96            Logging.error(tr("Unexpected format for port number in preference ''{0}''. Got ''{1}''.", property, value));
     97            Logging.error(tr("The proxy will not be used."));
    9798            return 0;
    9899        }
    99100        if (port <= 0 || port > 65_535) {
    100             Main.error(tr("Illegal port number in preference ''{0}''. Got {1}.", property, port));
    101             Main.error(tr("The proxy will not be used."));
     101            Logging.error(tr("Illegal port number in preference ''{0}''. Got {1}.", property, port));
     102            Logging.error(tr("The proxy will not be used."));
    102103            return 0;
    103104        }
     
    116117            proxyPolicy = ProxyPolicy.fromName(value);
    117118            if (proxyPolicy == null) {
    118                 Main.warn(tr("Unexpected value for preference ''{0}'' found. Got ''{1}''. Will use no proxy.",
     119                Logging.warn(tr("Unexpected value for preference ''{0}'' found. Got ''{1}''. Will use no proxy.",
    119120                        ProxyPreferencesPanel.PROXY_POLICY, value));
    120121                proxyPolicy = ProxyPolicy.NO_PROXY;
     
    128129                httpProxySocketAddress = new InetSocketAddress(host, port);
    129130            } else {
    130                 Main.warn(tr("Unexpected parameters for HTTP proxy. Got host ''{0}'' and port ''{1}''.", host, port));
    131                 Main.warn(tr("The proxy will not be used."));
     131                Logging.warn(tr("Unexpected parameters for HTTP proxy. Got host ''{0}'' and port ''{1}''.", host, port));
     132                Logging.warn(tr("The proxy will not be used."));
    132133            }
    133134        }
     
    140141                socksProxySocketAddress = new InetSocketAddress(host, port);
    141142            } else {
    142                 Main.warn(tr("Unexpected parameters for SOCKS proxy. Got host ''{0}'' and port ''{1}''.", host, port));
    143                 Main.warn(tr("The proxy will not be used."));
     143                Logging.warn(tr("Unexpected parameters for SOCKS proxy. Got host ''{0}'' and port ''{1}''.", host, port));
     144                Logging.warn(tr("The proxy will not be used."));
    144145            }
    145146        }
     
    153154    public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
    154155        // Just log something. The network stack will also throw an exception which will be caught somewhere else
    155         Main.error(tr("Connection to proxy ''{0}'' for URI ''{1}'' failed. Exception was: {2}", sa.toString(), uri.toString(), ioe.toString()));
     156        Logging.error(tr("Connection to proxy ''{0}'' for URI ''{1}'' failed. Exception was: {2}",
     157                sa.toString(), uri.toString(), ioe.toString()));
    156158        // Remember errors to give a friendly user message asking to review proxy configuration
    157159        errorResources.add(uri.toString());
     
    203205        case USE_SYSTEM_SETTINGS:
    204206            if (!jvmWillUseSystemProxies) {
    205                 Main.warn(tr("The JVM is not configured to lookup proxies from the system settings. "+
     207                Logging.warn(tr("The JVM is not configured to lookup proxies from the system settings. "+
    206208                        "The property ''java.net.useSystemProxies'' was missing at startup time.  Will not use a proxy."));
    207209                return NO_PROXY_LIST;
  • trunk/src/org/openstreetmap/josm/io/FileImporter.java

    r12112 r12620  
    1616import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1717import org.openstreetmap.josm.gui.util.GuiHelper;
     18import org.openstreetmap.josm.tools.Logging;
    1819import org.openstreetmap.josm.tools.Utils;
    1920import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
     
    8990    public boolean importDataHandleExceptions(File f, ProgressMonitor progressMonitor) {
    9091        try {
    91             Main.info("Open file: " + f.getAbsolutePath() + " (" + f.length() + " bytes)");
     92            Logging.info("Open file: " + f.getAbsolutePath() + " (" + f.length() + " bytes)");
    9293            importData(f, progressMonitor);
    9394            return true;
     
    110111
    111112    private static void displayError(File f, Exception e) {
    112         Main.error(e);
     113        Logging.error(e);
    113114        HelpAwareOptionPane.showMessageDialogInEDT(
    114115                Main.parent,
     
    137138    public boolean importDataHandleExceptions(List<File> files, ProgressMonitor progressMonitor) {
    138139        try {
    139             Main.info("Open "+files.size()+" files");
     140            Logging.info("Open "+files.size()+" files");
    140141            importData(files, progressMonitor);
    141142            return true;
    142143        } catch (IOException | IllegalDataException e) {
    143             Main.error(e);
     144            Logging.error(e);
    144145            HelpAwareOptionPane.showMessageDialogInEDT(
    145146                    Main.parent,
  • trunk/src/org/openstreetmap/josm/io/FileWatcher.java

    r11620 r12620  
    2323import org.openstreetmap.josm.gui.preferences.SourceEntry;
    2424import org.openstreetmap.josm.tools.CheckParameterUtil;
     25import org.openstreetmap.josm.tools.Logging;
    2526
    2627/**
     
    4445            thread = new Thread((Runnable) this::processEvents, "File Watcher");
    4546        } catch (IOException e) {
    46             Main.error(e);
     47            Logging.error(e);
    4748        }
    4849    }
     
    104105     */
    105106    private void processEvents() {
    106         if (Main.isDebugEnabled()) {
    107             Main.debug("File watcher thread started");
    108         }
     107        Logging.debug("File watcher thread started");
    109108        while (true) {
    110109
     
    140139                    SourceEntry rule = ruleMap.get(fullPath);
    141140                    if (style != null) {
    142                         Main.info("Map style "+style.getDisplayString()+" has been modified. Reloading style...");
     141                        Logging.info("Map style "+style.getDisplayString()+" has been modified. Reloading style...");
    143142                        Main.worker.submit(new MapPaintStyleLoader(Collections.singleton(style)));
    144143                    } else if (rule != null) {
    145                         Main.info("Validator rule "+rule.getDisplayString()+" has been modified. Reloading rule...");
     144                        Logging.info("Validator rule "+rule.getDisplayString()+" has been modified. Reloading rule...");
    146145                        MapCSSTagChecker tagChecker = OsmValidator.getTest(MapCSSTagChecker.class);
    147146                        if (tagChecker != null) {
     
    149148                                tagChecker.addMapCSS(rule.url);
    150149                            } catch (IOException | ParseException e) {
    151                                 Main.warn(e);
     150                                Logging.warn(e);
    152151                            }
    153152                        }
    154                     } else if (Main.isDebugEnabled()) {
    155                         Main.debug("Received "+kind.name()+" event for unregistered file: "+fullPath);
     153                    } else if (Logging.isDebugEnabled()) {
     154                        Logging.debug("Received {0} event for unregistered file: {1}", kind.name(), fullPath);
    156155                    }
    157156                }
  • trunk/src/org/openstreetmap/josm/io/GeoJSONWriter.java

    r12537 r12620  
    1818import javax.json.stream.JsonGenerator;
    1919
    20 import org.openstreetmap.josm.Main;
    2120import org.openstreetmap.josm.data.Bounds;
    2221import org.openstreetmap.josm.data.coor.EastNorth;
     
    3433import org.openstreetmap.josm.gui.mappaint.ElemStyles;
    3534import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference;
     35import org.openstreetmap.josm.tools.Logging;
    3636import org.openstreetmap.josm.tools.Pair;
    3737
     
    135135                geomObj.add("coordinates", multiPolygon);
    136136            } catch (MultipolygonBuilder.JoinedPolygonCreationException ex) {
    137                 Main.warn("GeoJSON: Failed to export multipolygon {0}", r.getUniqueId());
    138                 Main.warn(ex);
     137                Logging.warn("GeoJSON: Failed to export multipolygon {0}", r.getUniqueId());
     138                Logging.warn(ex);
    139139            }
    140140        }
  • trunk/src/org/openstreetmap/josm/io/GpxExporter.java

    r12279 r12620  
    3535import org.openstreetmap.josm.tools.CheckParameterUtil;
    3636import org.openstreetmap.josm.tools.GBC;
     37import org.openstreetmap.josm.tools.Logging;
    3738
    3839/**
     
    205206            fo.flush();
    206207        } catch (IOException ex) {
    207             Main.error(ex);
     208            Logging.error(ex);
    208209            JOptionPane.showMessageDialog(Main.parent, tr("Error while exporting {0}:\n{1}", fn, ex.getMessage()),
    209210                    tr("Error"), JOptionPane.ERROR_MESSAGE);
  • trunk/src/org/openstreetmap/josm/io/GpxImporter.java

    r12421 r12620  
    1717import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1818import org.openstreetmap.josm.gui.util.GuiHelper;
     19import org.openstreetmap.josm.tools.Logging;
    1920import org.xml.sax.SAXException;
    2021
     
    105106            addLayers(loadLayers(r.getGpxData(), parsedProperly, fileName, tr("Markers from {0}", fileName)));
    106107        } catch (SAXException e) {
    107             Main.error(e);
     108            Logging.error(e);
    108109            throw new IOException(tr("Parsing data for layer ''{0}'' failed", fileName), e);
    109110        }
     
    184185            return loadLayers(r.getGpxData(), parsedProperly, gpxLayerName, markerLayerName);
    185186        } catch (SAXException e) {
    186             Main.error(e);
     187            Logging.error(e);
    187188            throw new IOException(tr("Parsing data for layer ''{0}'' failed", gpxLayerName), e);
    188189        }
  • trunk/src/org/openstreetmap/josm/io/GpxReader.java

    r12156 r12620  
    1717import javax.xml.parsers.ParserConfigurationException;
    1818
    19 import org.openstreetmap.josm.Main;
    2019import org.openstreetmap.josm.data.Bounds;
    2120import org.openstreetmap.josm.data.coor.LatLon;
     
    2726import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack;
    2827import org.openstreetmap.josm.data.gpx.WayPoint;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.Utils;
    3030import org.xml.sax.Attributes;
     
    581581                    message += ' ' + tr("(at line {0}, column {1})", spe.getLineNumber(), spe.getColumnNumber());
    582582                }
    583                 Main.warn(message);
     583                Logging.warn(message);
    584584                return false;
    585585            } else
    586586                throw e;
    587587        } catch (ParserConfigurationException e) {
    588             Main.error(e); // broken SAXException chaining
     588            Logging.error(e); // broken SAXException chaining
    589589            throw new SAXException(e);
    590590        }
  • trunk/src/org/openstreetmap/josm/io/InvalidXmlCharacterFilter.java

    r9078 r12620  
    55import java.io.Reader;
    66
    7 import org.openstreetmap.josm.Main;
     7import org.openstreetmap.josm.tools.Logging;
    88
    99/**
     
    6464        if (in < 0x20 && INVALID_CHARS[in]) {
    6565            if (firstWarning) {
    66                 Main.warn("Invalid xml character encountered: '"+in+"'.");
     66                Logging.warn("Invalid xml character encountered: '"+in+"'.");
    6767                firstWarning = false;
    6868            }
  • trunk/src/org/openstreetmap/josm/io/MessageNotifier.java

    r11969 r12620  
    3030import org.openstreetmap.josm.io.auth.JosmPreferencesCredentialAgent;
    3131import org.openstreetmap.josm.tools.GBC;
     32import org.openstreetmap.josm.tools.Logging;
    3233import org.openstreetmap.josm.tools.Utils;
    3334
     
    8687                }
    8788            } catch (OsmTransferException e) {
    88                 Main.warn(e);
     89                Logging.warn(e);
    8990            }
    9091        }
     
    9798        int interval = PROP_INTERVAL.get();
    9899        if (Main.isOffline(OnlineResource.OSM_API)) {
    99             Main.info(tr("{0} not available (offline mode)", tr("Message notifier")));
     100            Logging.info(tr("{0} not available (offline mode)", tr("Message notifier")));
    100101        } else if (!isRunning() && interval > 0 && isUserEnoughIdentified()) {
    101102            task = EXECUTOR.scheduleAtFixedRate(WORKER, 0, TimeUnit.MINUTES.toSeconds(interval), TimeUnit.SECONDS);
    102             Main.info("Message notifier active (checks every "+interval+" minute"+(interval > 1 ? "s" : "")+')');
     103            Logging.info("Message notifier active (checks every "+interval+" minute"+(interval > 1 ? "s" : "")+')');
    103104        }
    104105    }
     
    110111        if (isRunning()) {
    111112            task.cancel(false);
    112             Main.info("Message notifier inactive");
     113            Logging.info("Message notifier inactive");
    113114            task = null;
    114115        }
     
    153154                }
    154155            } catch (CredentialsAgentException e) {
    155                 Main.warn(e, "Unable to get credentials:");
     156                Logging.log(Logging.LEVEL_WARN, "Unable to get credentials:", e);
    156157            }
    157158        }
  • trunk/src/org/openstreetmap/josm/io/MultiFetchServerObjectReader.java

    r11809 r12620  
    3838import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    3939import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     40import org.openstreetmap.josm.tools.Logging;
    4041import org.openstreetmap.josm.tools.Utils;
    4142
     
    5152 *    reader.parseOsm();
    5253 *    if (!reader.getMissingPrimitives().isEmpty()) {
    53  *        Main.info("There are missing primitives: " + reader.getMissingPrimitives());
     54 *        Logging.info("There are missing primitives: " + reader.getMissingPrimitives());
    5455 *    }
    5556 *    if (!reader.getSkippedWays().isEmpty()) {
    56  *       Main.info("There are skipped ways: " + reader.getMissingPrimitives());
     57 *       Logging.info("There are skipped ways: " + reader.getMissingPrimitives());
    5758 *    }
    5859 * </pre>
     
    343344                }
    344345            } catch (InterruptedException | ExecutionException e) {
    345                 Main.error(e);
     346                Logging.error(e);
    346347            }
    347348        }
     
    487488            } catch (OsmApiException e) {
    488489                if (e.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND) {
    489                     Main.info(tr("Server replied with response code 404, retrying with an individual request for each object."));
     490                    Logging.info(tr("Server replied with response code 404, retrying with an individual request for each object."));
    490491                    return singleGetIdPackage(type, pkg, progressMonitor);
    491492                } else {
     
    524525                }
    525526            } catch (IOException ex) {
    526                 Main.warn(ex);
     527                Logging.warn(ex);
    527528            }
    528529            return result;
     
    552553                }
    553554            } catch (IOException ex) {
    554                 Main.warn(ex);
     555                Logging.warn(ex);
    555556            }
    556557            return result;
     
    591592                } catch (OsmApiException e) {
    592593                    if (e.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND) {
    593                         Main.info(tr("Server replied with response code 404 for id {0}. Skipping.", Long.toString(id)));
     594                        Logging.info(tr("Server replied with response code 404 for id {0}. Skipping.", Long.toString(id)));
    594595                        result.missingPrimitives.add(new SimplePrimitiveId(id, type));
    595596                    } else {
  • trunk/src/org/openstreetmap/josm/io/NameFinder.java

    r12558 r12620  
    1313import javax.xml.parsers.ParserConfigurationException;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.Bounds;
    1716import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     
    2120import org.openstreetmap.josm.tools.HttpClient;
    2221import org.openstreetmap.josm.tools.HttpClient.Response;
     22import org.openstreetmap.josm.tools.Logging;
    2323import org.openstreetmap.josm.tools.OsmUrlToBounds;
    2424import org.openstreetmap.josm.tools.UncheckedParseException;
     
    250250                }
    251251            } catch (NumberFormatException ex) {
    252                 Main.error(ex); // SAXException does not chain correctly
     252                Logging.error(ex); // SAXException does not chain correctly
    253253                throw new SAXException(ex.getMessage(), ex);
    254254            } catch (NullPointerException ex) { // NOPMD
    255                 Main.error(ex); // SAXException does not chain correctly
     255                Logging.error(ex); // SAXException does not chain correctly
    256256                throw new SAXException(tr("Null pointer exception, possibly some missing tags."), ex);
    257257            }
  • trunk/src/org/openstreetmap/josm/io/NoteExporter.java

    r11456 r12620  
    99import java.io.OutputStream;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.actions.ExtensionFileFilter;
    1312import org.openstreetmap.josm.gui.layer.Layer;
    1413import org.openstreetmap.josm.gui.layer.NoteLayer;
     14import org.openstreetmap.josm.tools.Logging;
    1515
    1616/**
     
    3737    @Override
    3838    public void exportData(File file, Layer layer) throws IOException {
    39         Main.info("exporting notes to file: " + file);
     39        Logging.info("exporting notes to file: " + file);
    4040        if (layer instanceof NoteLayer) {
    4141            try (OutputStream os = new FileOutputStream(file);
  • trunk/src/org/openstreetmap/josm/io/NoteImporter.java

    r10432 r12620  
    1414import org.openstreetmap.josm.gui.layer.NoteLayer;
    1515import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     16import org.openstreetmap.josm.tools.Logging;
    1617import org.xml.sax.SAXException;
    1718
     
    3233    @Override
    3334    public void importData(final File file, ProgressMonitor progressMonitor) throws IOException {
    34         if (Main.isDebugEnabled()) {
    35             Main.debug("importing notes file " + file.getAbsolutePath());
     35        if (Logging.isDebugEnabled()) {
     36            Logging.debug("importing notes file {0}", file.getAbsolutePath());
    3637        }
    3738        try (InputStream is = Compression.getUncompressedFileInputStream(file)) {
     
    4142            }
    4243        } catch (SAXException e) {
    43             Main.error("error opening up notes file");
    44             Main.error(e, true);
     44            Logging.error("error opening up notes file");
     45            Logging.error(e);
    4546            throw new IOException(e.getMessage(), e);
    4647        }
  • trunk/src/org/openstreetmap/josm/io/NoteReader.java

    r11553 r12620  
    1414import javax.xml.parsers.ParserConfigurationException;
    1515
    16 import org.openstreetmap.josm.Main;
    1716import org.openstreetmap.josm.data.coor.LatLon;
    1817import org.openstreetmap.josm.data.notes.Note;
     
    2019import org.openstreetmap.josm.data.notes.NoteComment.Action;
    2120import org.openstreetmap.josm.data.osm.User;
     21import org.openstreetmap.josm.tools.Logging;
    2222import org.openstreetmap.josm.tools.Utils;
    2323import org.openstreetmap.josm.tools.date.DateUtils;
     
    218218            Utils.parseSafeSAX(inputSource, parser);
    219219        } catch (ParserConfigurationException e) {
    220             Main.error(e); // broken SAXException chaining
     220            Logging.error(e); // broken SAXException chaining
    221221            throw new SAXException(e);
    222222        }
  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r11535 r12620  
    3737import org.openstreetmap.josm.tools.CheckParameterUtil;
    3838import org.openstreetmap.josm.tools.HttpClient;
     39import org.openstreetmap.josm.tools.Logging;
    3940import org.openstreetmap.josm.tools.Utils;
    4041import org.openstreetmap.josm.tools.XmlParsingException;
     
    155156            host = (new URL(serverUrl)).getHost();
    156157        } catch (MalformedURLException e) {
    157             Main.warn(e);
     158            Logging.warn(e);
    158159        }
    159160        return host;
     
    212213                initializeCapabilities(cache.updateIfRequiredString());
    213214            } catch (SAXParseException parseException) {
    214                 Main.trace(parseException);
     215                Logging.trace(parseException);
    215216                // XML parsing may fail if JOSM previously stored a corrupted capabilities document (see #8278)
    216217                // In that case, force update and try again
     
    219220            if (capabilities == null) {
    220221                if (Main.isOffline(OnlineResource.OSM_API)) {
    221                     Main.warn(tr("{0} not available (offline mode)", tr("OSM API")));
     222                    Logging.warn(tr("{0} not available (offline mode)", tr("OSM API")));
    222223                } else {
    223                     Main.error(tr("Unable to initialize OSM API."));
     224                    Logging.error(tr("Unable to initialize OSM API."));
    224225                }
    225226                return;
    226227            } else if (!capabilities.supportsVersion("0.6")) {
    227                 Main.error(tr("This version of JOSM is incompatible with the configured server."));
    228                 Main.error(tr("It supports protocol version 0.6, while the server says it supports {0} to {1}.",
     228                Logging.error(tr("This version of JOSM is incompatible with the configured server."));
     229                Logging.error(tr("It supports protocol version 0.6, while the server says it supports {0} to {1}.",
    229230                        capabilities.get("version", "minimum"), capabilities.get("version", "maximum")));
    230231                return;
     
    243244                for (Layer l : Main.getLayerManager().getLayersOfType(ImageryLayer.class)) {
    244245                    if (((ImageryLayer) l).getInfo().isBlacklisted()) {
    245                         Main.info(tr("Removed layer {0} because it is not allowed by the configured API.", l.getName()));
     246                        Logging.info(tr("Removed layer {0} because it is not allowed by the configured API.", l.getName()));
    246247                        Main.getLayerManager().removeLayer(l);
    247248                    }
     
    284285            osmWriter.flush();
    285286        } catch (IOException e) {
    286             Main.warn(e);
     287            Logging.warn(e);
    287288        }
    288289        return swriter.toString();
     
    303304            osmWriter.flush();
    304305        } catch (IOException e) {
    305             Main.warn(e);
     306            Logging.warn(e);
    306307        }
    307308        return swriter.toString();
     
    552553
    553554    private void sleepAndListen(int retry, ProgressMonitor monitor) throws OsmTransferCanceledException {
    554         Main.info(tr("Waiting 10 seconds ... "));
     555        Logging.info(tr("Waiting 10 seconds ... "));
    555556        for (int i = 0; i < 10; i++) {
    556557            if (monitor != null) {
     
    562563                Thread.sleep(1000);
    563564            } catch (InterruptedException ex) {
    564                 Main.warn("InterruptedException in "+getClass().getSimpleName()+" during sleep");
     565                Logging.warn("InterruptedException in "+getClass().getSimpleName()+" during sleep");
    565566                Thread.currentThread().interrupt();
    566567            }
    567568        }
    568         Main.info(tr("OK - trying again."));
     569        Logging.info(tr("OK - trying again."));
    569570    }
    570571
     
    652653
    653654                final HttpClient.Response response = client.connect();
    654                 Main.info(response.getResponseMessage());
     655                Logging.info(response.getResponseMessage());
    655656                int retCode = response.getResponseCode();
    656657
    657658                if (retCode >= 500 && retries-- > 0) {
    658659                    sleepAndListen(retries, monitor);
    659                     Main.info(tr("Starting retry {0} of {1}.", getMaxRetries() - retries, getMaxRetries()));
     660                    Logging.info(tr("Starting retry {0} of {1}.", getMaxRetries() - retries, getMaxRetries()));
    660661                    continue;
    661662                }
     
    667668                if (response.getHeaderField("Error") != null) {
    668669                    errorHeader = response.getHeaderField("Error");
    669                     Main.error("Error header: " + errorHeader);
     670                    Logging.error("Error header: " + errorHeader);
    670671                } else if (retCode != HttpURLConnection.HTTP_OK && responseBody.length() > 0) {
    671                     Main.error("Error body: " + responseBody);
     672                    Logging.error("Error body: " + responseBody);
    672673                }
    673674                activeConnection.disconnect();
     
    859860            throw new OsmTransferException(tr("Note upload failed"));
    860861        } catch (SAXException | IOException e) {
    861             Main.error(e, true);
     862            Logging.error(e);
    862863            throw new OsmTransferException(tr("Error parsing note response from server"), e);
    863864        }
  • trunk/src/org/openstreetmap/josm/io/OsmApiException.java

    r10626 r12620  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import org.openstreetmap.josm.Main;
     5import org.openstreetmap.josm.tools.Logging;
    66
    77/**
     
    146146        } catch (IllegalArgumentException e) {
    147147            // Ignored
    148             Main.trace(e);
     148            Logging.trace(e);
    149149        }
    150150        try {
     
    157157        } catch (IllegalArgumentException e) {
    158158            // Ignored
    159             Main.trace(e);
     159            Logging.trace(e);
    160160        }
    161161        return sb.toString();
  • trunk/src/org/openstreetmap/josm/io/OsmChangeImporter.java

    r12470 r12620  
    1717import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1818import org.openstreetmap.josm.gui.util.GuiHelper;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    4344            importData(Compression.getUncompressedFileInputStream(file), file, progressMonitor);
    4445        } catch (FileNotFoundException e) {
    45             Main.error(e);
     46            Logging.error(e);
    4647            throw new IOException(tr("File ''{0}'' does not exist.", file.getName()), e);
    4748        }
  • trunk/src/org/openstreetmap/josm/io/OsmChangesetContentParser.java

    r9078 r12620  
    1212import javax.xml.parsers.ParserConfigurationException;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.data.osm.ChangesetDataSet;
    1615import org.openstreetmap.josm.data.osm.ChangesetDataSet.ChangesetModificationType;
     
    1817import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1918import org.openstreetmap.josm.tools.CheckParameterUtil;
     19import org.openstreetmap.josm.tools.Logging;
    2020import org.openstreetmap.josm.tools.Utils;
    2121import org.openstreetmap.josm.tools.XmlParsingException;
     
    6969                break;
    7070            default:
    71                 Main.warn(tr("Unsupported start element ''{0}'' in changeset content at position ({1},{2}). Skipping.",
     71                Logging.warn(tr("Unsupported start element ''{0}'' in changeset content at position ({1},{2}). Skipping.",
    7272                        qName, locator.getLineNumber(), locator.getColumnNumber()));
    7373            }
     
    9999                break;
    100100            default:
    101                 Main.warn(tr("Unsupported end element ''{0}'' in changeset content at position ({1},{2}). Skipping.",
     101                Logging.warn(tr("Unsupported end element ''{0}'' in changeset content at position ({1},{2}). Skipping.",
    102102                        qName, locator.getLineNumber(), locator.getColumnNumber()));
    103103            }
  • trunk/src/org/openstreetmap/josm/io/OsmConnection.java

    r12470 r12620  
    2323import org.openstreetmap.josm.io.auth.CredentialsManager;
    2424import org.openstreetmap.josm.tools.HttpClient;
     25import org.openstreetmap.josm.tools.Logging;
    2526import org.openstreetmap.josm.tools.Utils;
    2627
     
    148149        } else {
    149150            String msg = tr("Unexpected value for preference ''{0}''. Got ''{1}''.", "osm-server.auth-method", authMethod);
    150             Main.warn(msg);
     151            Logging.warn(msg);
    151152            throw new OsmTransferException(msg);
    152153        }
  • trunk/src/org/openstreetmap/josm/io/OsmExporter.java

    r11848 r12620  
    1919import org.openstreetmap.josm.gui.layer.Layer;
    2020import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     21import org.openstreetmap.josm.tools.Logging;
    2122import org.openstreetmap.josm.tools.Utils;
    2223
     
    9192            layer.onPostSaveToFile();
    9293        } catch (IOException e) {
    93             Main.error(e);
     94            Logging.error(e);
    9495            JOptionPane.showMessageDialog(
    9596                    Main.parent,
     
    106107                }
    107108            } catch (IOException e2) {
    108                 Main.error(e2);
     109                Logging.error(e2);
    109110                JOptionPane.showMessageDialog(
    110111                        Main.parent,
  • trunk/src/org/openstreetmap/josm/io/OsmHistoryReader.java

    r10462 r12620  
    1111import javax.xml.parsers.ParserConfigurationException;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
    1514import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
     
    1716import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1817import org.openstreetmap.josm.tools.CheckParameterUtil;
     18import org.openstreetmap.josm.tools.Logging;
    1919import org.openstreetmap.josm.tools.Utils;
    2020import org.xml.sax.Attributes;
     
    9494            Utils.parseSafeSAX(inputSource, new Parser());
    9595        } catch (ParserConfigurationException e) {
    96             Main.error(e); // broken SAXException chaining
     96            Logging.error(e); // broken SAXException chaining
    9797            throw new SAXException(e);
    9898        } finally {
  • trunk/src/org/openstreetmap/josm/io/OsmImporter.java

    r12470 r12620  
    1818import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1919import org.openstreetmap.josm.gui.util.GuiHelper;
     20import org.openstreetmap.josm.tools.Logging;
    2021
    2122/**
     
    7980            importData(in, file, progressMonitor);
    8081        } catch (FileNotFoundException e) {
    81             Main.error(e);
     82            Logging.error(e);
    8283            throw new IOException(tr("File ''{0}'' does not exist.", file.getName()), e);
    8384        }
  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r12588 r12620  
    2121import javax.xml.stream.XMLStreamReader;
    2222
    23 import org.openstreetmap.josm.Main;
    2423import org.openstreetmap.josm.data.Bounds;
    2524import org.openstreetmap.josm.data.DataSource;
     
    4342import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    4443import org.openstreetmap.josm.tools.CheckParameterUtil;
     44import org.openstreetmap.josm.tools.Logging;
    4545import org.openstreetmap.josm.tools.UncheckedParseException;
    4646import org.openstreetmap.josm.tools.Utils;
     
    202202                Bounds copy = new Bounds(bounds);
    203203                bounds.normalize();
    204                 Main.info("Bbox " + copy + " is out of the world, normalized to " + bounds);
     204                Logging.info("Bbox " + copy + " is out of the world, normalized to " + bounds);
    205205            }
    206206            DataSource src = new DataSource(bounds, origin);
     
    225225                nd.setCoor(ll);
    226226            } catch (NumberFormatException e) {
    227                 Main.trace(e);
     227                Logging.trace(e);
    228228            }
    229229        }
     
    277277        }
    278278        if (w.isDeleted() && !nodeIds.isEmpty()) {
    279             Main.info(tr("Deleted way {0} contains nodes", w.getUniqueId()));
     279            Logging.info(tr("Deleted way {0} contains nodes", w.getUniqueId()));
    280280            nodeIds = new ArrayList<>();
    281281        }
     
    327327        }
    328328        if (r.isDeleted() && !members.isEmpty()) {
    329             Main.info(tr("Deleted relation {0} contains members", r.getUniqueId()));
     329            Logging.info(tr("Deleted relation {0} contains members", r.getUniqueId()));
    330330            members = new ArrayList<>();
    331331        }
     
    410410        if (printWarning && ("note".equals(element) || "meta".equals(element))) {
    411411            // we know that Overpass API returns those elements
    412             Main.debug(tr("Undefined element ''{0}'' found in input stream. Skipping.", element));
     412            Logging.debug(tr("Undefined element ''{0}'' found in input stream. Skipping.", element));
    413413        } else if (printWarning) {
    414             Main.info(tr("Undefined element ''{0}'' found in input stream. Skipping.", element));
     414            Logging.info(tr("Undefined element ''{0}'' found in input stream. Skipping.", element));
    415415        }
    416416        while (true) {
     
    505505                            Long.toString(current.getUniqueId()), versionString));
    506506                } else if (version < 0 && current.isNew()) {
    507                     Main.warn(tr("Normalizing value of attribute ''version'' of element {0} to {2}, API version is ''{3}''. Got {1}.",
     507                    Logging.warn(tr("Normalizing value of attribute ''version'' of element {0} to {2}, API version is ''{3}''. Got {1}.",
    508508                            current.getUniqueId(), version, 0, "0.6"));
    509509                    version = 0;
     
    539539                current.setChangesetId(Integer.parseInt(v));
    540540            } catch (IllegalArgumentException e) {
    541                 Main.debug(e.getMessage());
     541                Logging.debug(e.getMessage());
    542542                if (current.isNew()) {
    543543                    // for a new primitive we just log a warning
    544                     Main.info(tr("Illegal value for attribute ''changeset'' on new object {1}. Got {0}. Resetting to 0.",
     544                    Logging.info(tr("Illegal value for attribute ''changeset'' on new object {1}. Got {0}. Resetting to 0.",
    545545                            v, current.getUniqueId()));
    546546                    current.setChangesetId(0);
     
    551551            } catch (IllegalStateException e) {
    552552                // thrown for positive changeset id on new primitives
    553                 Main.debug(e);
    554                 Main.info(e.getMessage());
     553                Logging.debug(e);
     554                Logging.info(e.getMessage());
    555555                current.setChangesetId(0);
    556556            }
     
    558558                if (current.isNew()) {
    559559                    // for a new primitive we just log a warning
    560                     Main.info(tr("Illegal value for attribute ''changeset'' on new object {1}. Got {0}. Resetting to 0.",
     560                    Logging.info(tr("Illegal value for attribute ''changeset'' on new object {1}. Got {0}. Resetting to 0.",
    561561                            v, current.getUniqueId()));
    562562                    current.setChangesetId(0);
  • trunk/src/org/openstreetmap/josm/io/OsmServerChangesetReader.java

    r11193 r12620  
    1313import java.util.List;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.Changeset;
    1716import org.openstreetmap.josm.data.osm.ChangesetDataSet;
     
    2019import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    2120import org.openstreetmap.josm.tools.CheckParameterUtil;
     21import org.openstreetmap.josm.tools.Logging;
    2222import org.openstreetmap.josm.tools.XmlParsingException;
    2323
     
    6969                result = OsmChangesetParser.parse(in, monitor.createSubTaskMonitor(1, true));
    7070            } catch (IOException e) {
    71                 Main.warn(e);
     71                Logging.warn(e);
    7272            }
    7373        } catch (OsmTransferException e) {
     
    110110                result = changesets.get(0);
    111111            } catch (IOException e) {
    112                 Main.warn(e);
     112                Logging.warn(e);
    113113            }
    114114        } catch (OsmTransferException e) {
     
    160160                    ret.addAll(changesets);
    161161                } catch (IOException e) {
    162                     Main.warn(e);
     162                    Logging.warn(e);
    163163                }
    164164                monitor.worked(1);
     
    201201                result = parser.parse(monitor.createSubTaskMonitor(1, true));
    202202            } catch (IOException e) {
    203                 Main.warn(e);
     203                Logging.warn(e);
    204204            }
    205205        } catch (XmlParsingException e) {
  • trunk/src/org/openstreetmap/josm/io/OsmServerReader.java

    r12596 r12620  
    2121import org.openstreetmap.josm.io.auth.CredentialsManager;
    2222import org.openstreetmap.josm.tools.HttpClient;
     23import org.openstreetmap.josm.tools.Logging;
    2324import org.openstreetmap.josm.tools.Utils;
    2425import org.openstreetmap.josm.tools.XmlParsingException;
     
    4849            doAuthenticate = OsmApi.isUsingOAuth() && CredentialsManager.getInstance().lookupOAuthAccessToken() != null;
    4950        } catch (CredentialsAgentException e) {
    50             Main.warn(e);
     51            Logging.warn(e);
    5152        }
    5253    }
     
    186187                response = client.connect(progressMonitor);
    187188            } catch (IOException e) {
    188                 Main.error(e);
     189                Logging.error(e);
    189190                OsmTransferException ote = new OsmTransferException(
    190191                        tr("Could not connect to the OSM server. Please check your internet connection."), e);
     
    221222            return response.fetchContent();
    222223        } catch (IOException e) {
    223             Main.error(e);
     224            Logging.error(e);
    224225            return tr("Reading error text failed.");
    225226        }
  • trunk/src/org/openstreetmap/josm/io/OverpassDownloadReader.java

    r12598 r12620  
    1919import javax.xml.stream.XMLStreamException;
    2020
    21 import org.openstreetmap.josm.Main;
    2221import org.openstreetmap.josm.data.Bounds;
    2322import org.openstreetmap.josm.data.DataSource;
     
    2726import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    2827import org.openstreetmap.josm.tools.HttpClient;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.UncheckedParseException;
    3030import org.openstreetmap.josm.tools.Utils;
     
    168168                        break;
    169169                    default:
    170                         Main.warn("Unsupported syntax: " + matcher.group(1));
     170                        Logging.warn("Unsupported syntax: " + matcher.group(1));
    171171                }
    172172            } catch (UncheckedParseException ex) {
    173173                final String msg = tr("Failed to evaluate {0}", matcher.group());
    174                 Main.warn(ex, msg);
     174                Logging.log(Logging.LEVEL_WARN, msg, ex);
    175175                matcher.appendReplacement(sb, "// " + msg + "\n");
    176176            }
     
    245245                    reader = readerClass.getDeclaredConstructor().newInstance();
    246246                } catch (ReflectiveOperationException | IllegalArgumentException | SecurityException e) {
    247                     Main.error(e);
     247                    Logging.error(e);
    248248                }
    249249            }
  • trunk/src/org/openstreetmap/josm/io/audio/AudioPlayer.java

    r12565 r12620  
    77import org.openstreetmap.josm.Main;
    88import org.openstreetmap.josm.tools.JosmRuntimeException;
     9import org.openstreetmap.josm.tools.Logging;
    910
    1011/**
     
    210211            return audioPlayer;
    211212        } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException ex) {
    212             Main.error(ex);
     213            Logging.error(ex);
    213214            return null;
    214215        }
     
    223224                pause();
    224225            } catch (InterruptedException | IOException e) {
    225                 Main.warn(e);
     226                Logging.warn(e);
    226227            }
    227228            audioPlayer.playingUrl = null;
     
    238239            soundPlayer = new JavaFxMediaPlayer();
    239240        } catch (NoClassDefFoundError | InterruptedException e) {
    240             Main.debug(e);
    241             Main.warn("Java FX is unavailable. Falling back to Java Sound API");
     241            Logging.debug(e);
     242            Logging.warn("Java FX is unavailable. Falling back to Java Sound API");
    242243            soundPlayer = new JavaSoundPlayer(leadIn, calibration);
    243244        }
     
    298299                    command.ok(stateChange);
    299300                } catch (AudioException | IOException | SecurityException | IllegalArgumentException startPlayingException) {
    300                     Main.error(startPlayingException);
     301                    Logging.error(startPlayingException);
    301302                    command.failed(startPlayingException); // sets state
    302303                }
    303304            } catch (AudioException | IOException e) {
    304305                state = State.NOTPLAYING;
    305                 Main.error(e);
     306                Logging.error(e);
    306307            }
    307308        }
  • trunk/src/org/openstreetmap/josm/io/audio/AudioUtil.java

    r12328 r12620  
    1616
    1717import org.openstreetmap.josm.Main;
     18import org.openstreetmap.josm.tools.Logging;
    1819
    1920/**
     
    4647            return naturalLength / calibration;
    4748        } catch (UnsupportedAudioFileException | IOException e) {
    48             Main.debug(e);
     49            Logging.debug(e);
    4950            return 0.0;
    5051        }
     
    6263        else
    6364            msg = tr(msg);
    64         Main.error(msg);
     65        Logging.error(msg);
    6566        if (!GraphicsEnvironment.isHeadless()) {
    6667            JOptionPane.showMessageDialog(Main.parent,
  • trunk/src/org/openstreetmap/josm/io/audio/JavaSoundPlayer.java

    r12414 r12620  
    1515import javax.sound.sampled.UnsupportedAudioFileException;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.io.audio.AudioPlayer.Execute;
    1918import org.openstreetmap.josm.io.audio.AudioPlayer.State;
    2019import org.openstreetmap.josm.tools.ListenerList;
     20import org.openstreetmap.josm.tools.Logging;
    2121import org.openstreetmap.josm.tools.Utils;
    2222
     
    9090                    if (skippedBytes == 0) {
    9191                        // Avoid inifinite loop
    92                         Main.warn("Unable to skip bytes from audio input stream");
     92                        Logging.warn("Unable to skip bytes from audio input stream");
    9393                        bytesToSkip = 0;
    9494                    }
  • trunk/src/org/openstreetmap/josm/io/auth/CredentialsManager.java

    r10627 r12620  
    77import java.util.Objects;
    88
    9 import org.openstreetmap.josm.Main;
    109import org.openstreetmap.josm.data.oauth.OAuthToken;
    1110import org.openstreetmap.josm.gui.JosmUserIdentityManager;
    1211import org.openstreetmap.josm.io.OsmApi;
    1312import org.openstreetmap.josm.tools.CheckParameterUtil;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    104104            }
    105105        } catch (CredentialsAgentException ex) {
    106             Main.debug(ex);
     106            Logging.debug(ex);
    107107            return null;
    108108        }
  • trunk/src/org/openstreetmap/josm/io/auth/DefaultAuthenticator.java

    r9396 r12620  
    88import java.util.Objects;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.io.OsmApi;
     11import org.openstreetmap.josm.tools.Logging;
    1212import org.openstreetmap.josm.tools.Pair;
    1313
     
    6565            return new PasswordAuthentication(response.getUsername(), response.getPassword());
    6666        } catch (CredentialsAgentException e) {
    67             Main.error(e);
     67            Logging.error(e);
    6868            return null;
    6969        }
  • trunk/src/org/openstreetmap/josm/io/imagery/ImageryReader.java

    r12279 r12620  
    1515import javax.xml.parsers.ParserConfigurationException;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.data.imagery.ImageryInfo;
    1918import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryBounds;
     
    2423import org.openstreetmap.josm.tools.JosmRuntimeException;
    2524import org.openstreetmap.josm.tools.LanguageInfo;
     25import org.openstreetmap.josm.tools.Logging;
    2626import org.openstreetmap.josm.tools.MultiMap;
    2727import org.openstreetmap.josm.tools.Utils;
     
    9797            throw e;
    9898        } catch (ParserConfigurationException e) {
    99             Main.error(e); // broken SAXException chaining
     99            Logging.error(e); // broken SAXException chaining
    100100            throw new SAXException(e);
    101101        }
     
    219219                                        atts.getValue("max-lon"), ",");
    220220                    } catch (IllegalArgumentException e) {
    221                         Main.trace(e);
     221                        Logging.trace(e);
    222222                        break;
    223223                    }
     
    252252                        shape.addPoint(atts.getValue("lat"), atts.getValue("lon"));
    253253                    } catch (IllegalArgumentException e) {
    254                         Main.trace(e);
     254                        Logging.trace(e);
    255255                        break;
    256256                    }
  • trunk/src/org/openstreetmap/josm/io/imagery/WMSImagery.java

    r12557 r12620  
    2525import javax.xml.parsers.ParserConfigurationException;
    2626
    27 import org.openstreetmap.josm.Main;
    2827import org.openstreetmap.josm.data.Bounds;
    2928import org.openstreetmap.josm.data.imagery.ImageryInfo;
     
    3130import org.openstreetmap.josm.tools.HttpClient;
    3231import org.openstreetmap.josm.tools.HttpClient.Response;
     32import org.openstreetmap.josm.tools.Logging;
    3333import org.openstreetmap.josm.tools.Utils;
    3434import org.w3c.dom.Document;
     
    223223            serviceUrl = new URL(serviceUrlStr);
    224224        } catch (HeadlessException e) {
    225             Main.warn(e);
     225            Logging.warn(e);
    226226            return;
    227227        }
     
    229229        final Response response = HttpClient.create(getCapabilitiesUrl).connect();
    230230        final String incomingData = response.fetchContent();
    231         Main.debug("Server response to Capabilities request:");
    232         Main.debug(incomingData);
     231        Logging.debug("Server response to Capabilities request:");
     232        Logging.debug(incomingData);
    233233
    234234        if (response.getResponseCode() >= 400) {
     
    239239            DocumentBuilder builder = Utils.newSafeDOMBuilder();
    240240            builder.setEntityResolver((publicId, systemId) -> {
    241                 Main.info("Ignoring DTD " + publicId + ", " + systemId);
     241                Logging.info("Ignoring DTD " + publicId + ", " + systemId);
    242242                return new InputSource(new StringReader(""));
    243243            });
     
    267267                String baseURL = child.getAttribute("xlink:href");
    268268                if (!baseURL.equals(serviceUrlStr)) {
    269                     Main.info("GetCapabilities specifies a different service URL: " + baseURL);
     269                    Logging.info("GetCapabilities specifies a different service URL: " + baseURL);
    270270                    serviceUrl = new URL(baseURL);
    271271                }
     
    283283        boolean isFormatSupported = isImageFormatSupported(format);
    284284        if (!isFormatSupported) {
    285             Main.info("Skipping unsupported image format {0}", format);
     285            Logging.info("Skipping unsupported image format {0}", format);
    286286        }
    287287        return isFormatSupported;
  • trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java

    r12617 r12620  
    1616import java.util.Optional;
    1717
    18 import org.openstreetmap.josm.Main;
    1918import org.openstreetmap.josm.data.coor.LatLon;
    2019import org.openstreetmap.josm.data.gpx.GpxConstants;
     
    2322import org.openstreetmap.josm.data.gpx.WayPoint;
    2423import org.openstreetmap.josm.io.IllegalDataException;
     24import org.openstreetmap.josm.tools.Logging;
    2525import org.openstreetmap.josm.tools.date.DateUtils;
    2626
     
    209209
    210210        } catch (IllegalDataException e) {
    211             Main.warn(e);
     211            Logging.warn(e);
    212212        }
    213213    }
     
    480480        } catch (IllegalArgumentException | IndexOutOfBoundsException | IllegalDataException ex) {
    481481            if (ps.malformed < 5) {
    482                 Main.warn(ex);
     482                Logging.warn(ex);
    483483            } else {
    484                 Main.debug(ex);
     484                Logging.debug(ex);
    485485            }
    486486            ps.malformed++;
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/RemoteControlHttpServer.java

    r11620 r12620  
    1010
    1111import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.tools.Logging;
    1213
    1314/**
     
    3738            instance4.start();
    3839        } catch (IOException ex) {
    39             Main.debug(ex);
    40             Main.warn(marktr("Cannot start IPv4 remotecontrol server on port {0}: {1}"),
     40            Logging.debug(ex);
     41            Logging.warn(marktr("Cannot start IPv4 remotecontrol server on port {0}: {1}"),
    4142                    Integer.toString(port), ex.getLocalizedMessage());
    4243        }
     
    4748            /* only show error when we also have no IPv4 */
    4849            if (instance4 == null) {
    49                 Main.debug(ex);
    50                 Main.warn(marktr("Cannot start IPv6 remotecontrol server on port {0}: {1}"),
     50                Logging.debug(ex);
     51                Logging.warn(marktr("Cannot start IPv6 remotecontrol server on port {0}: {1}"),
    5152                    Integer.toString(port), ex.getLocalizedMessage());
    5253            }
     
    6364                instance4.stopServer();
    6465            } catch (IOException ioe) {
    65                 Main.error(ioe);
     66                Logging.error(ioe);
    6667            }
    6768            instance4 = null;
     
    7172                instance6.stopServer();
    7273            } catch (IOException ioe) {
    73                 Main.error(ioe);
     74                Logging.error(ioe);
    7475            }
    7576            instance6 = null;
     
    9697    @Override
    9798    public void run() {
    98         Main.info(marktr("RemoteControl::Accepting remote connections on {0}:{1}"),
     99        Logging.info(marktr("RemoteControl::Accepting remote connections on {0}:{1}"),
    99100                server.getInetAddress(), Integer.toString(server.getLocalPort()));
    100101        while (true) {
     
    105106            } catch (SocketException e) {
    106107                if (!server.isClosed()) {
    107                     Main.error(e);
     108                    Logging.error(e);
    108109                } else {
    109110                    // stop the thread automatically if server is stopped
     
    111112                }
    112113            } catch (IOException ioe) {
    113                 Main.error(ioe);
     114                Logging.error(ioe);
    114115            }
    115116        }
     
    122123     */
    123124    public void stopServer() throws IOException {
    124         Main.info(marktr("RemoteControl::Server {0}:{1} stopped."),
     125        Logging.info(marktr("RemoteControl::Server {0}:{1} stopped."),
    125126        server.getInetAddress(), Integer.toString(server.getLocalPort()));
    126127        server.close();
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/RemoteControlHttpsServer.java

    r12458 r12620  
    4141import org.openstreetmap.josm.Main;
    4242import org.openstreetmap.josm.data.preferences.StringProperty;
     43import org.openstreetmap.josm.tools.Logging;
    4344
    4445import sun.security.util.ObjectIdentifier;
     
    208209
    209210        if (!path.toFile().exists()) {
    210             Main.debug("No keystore found, creating a new one");
     211            Logging.debug("No keystore found, creating a new one");
    211212
    212213            // Create new keystore like previous one generated with JDK keytool as follows:
     
    252253            ks.load(in, KEYSTORE_PASSWORD.get().toCharArray());
    253254
    254             if (Main.isDebugEnabled()) {
     255            if (Logging.isDebugEnabled()) {
    255256                for (Enumeration<String> aliases = ks.aliases(); aliases.hasMoreElements();) {
    256                     Main.debug("Alias in JOSM keystore: "+aliases.nextElement());
     257                    Logging.debug("Alias in JOSM keystore: {0}", aliases.nextElement());
    257258                }
    258259            }
     
    278279        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
    279280
    280         if (Main.isTraceEnabled()) {
    281             Main.trace("SSL Context protocol: " + sslContext.getProtocol());
    282             Main.trace("SSL Context provider: " + sslContext.getProvider());
     281        if (Logging.isTraceEnabled()) {
     282            Logging.trace("SSL Context protocol: {0}", sslContext.getProtocol());
     283            Logging.trace("SSL Context provider: {0}", sslContext.getProvider());
    283284        }
    284285
     
    316317                instance4.start();
    317318            } catch (IOException | GeneralSecurityException ex) {
    318                 Main.debug(ex);
    319                 Main.warn(marktr("Cannot start IPv4 remotecontrol https server on port {0}: {1}"),
     319                Logging.debug(ex);
     320                Logging.warn(marktr("Cannot start IPv4 remotecontrol https server on port {0}: {1}"),
    320321                        Integer.toString(port), ex.getLocalizedMessage());
    321322            }
     
    326327                /* only show error when we also have no IPv4 */
    327328                if (instance4 == null) {
    328                     Main.debug(ex);
    329                     Main.warn(marktr("Cannot start IPv6 remotecontrol https server on port {0}: {1}"),
     329                    Logging.debug(ex);
     330                    Logging.warn(marktr("Cannot start IPv6 remotecontrol https server on port {0}: {1}"),
    330331                        Integer.toString(port), ex.getLocalizedMessage());
    331332                }
     
    342343                instance4.stopServer();
    343344            } catch (IOException ioe) {
    344                 Main.error(ioe);
     345                Logging.error(ioe);
    345346            }
    346347            instance4 = null;
     
    350351                instance6.stopServer();
    351352            } catch (IOException ioe) {
    352                 Main.error(ioe);
     353                Logging.error(ioe);
    353354            }
    354355            instance6 = null;
     
    372373        // Create SSL Server factory
    373374        SSLServerSocketFactory factory = sslContext.getServerSocketFactory();
    374         if (Main.isTraceEnabled()) {
    375             Main.trace("SSL factory - Supported Cipher suites: "+Arrays.toString(factory.getSupportedCipherSuites()));
     375        if (Logging.isTraceEnabled()) {
     376            Logging.trace("SSL factory - Supported Cipher suites: {0}", Arrays.toString(factory.getSupportedCipherSuites()));
    376377        }
    377378
     
    379380            RemoteControl.getInet6Address() : RemoteControl.getInet4Address());
    380381
    381         if (Main.isTraceEnabled() && server instanceof SSLServerSocket) {
     382        if (Logging.isTraceEnabled() && server instanceof SSLServerSocket) {
    382383            SSLServerSocket sslServer = (SSLServerSocket) server;
    383             Main.trace("SSL server - Enabled Cipher suites: "+Arrays.toString(sslServer.getEnabledCipherSuites()));
    384             Main.trace("SSL server - Enabled Protocols: "+Arrays.toString(sslServer.getEnabledProtocols()));
    385             Main.trace("SSL server - Enable Session Creation: "+sslServer.getEnableSessionCreation());
    386             Main.trace("SSL server - Need Client Auth: "+sslServer.getNeedClientAuth());
    387             Main.trace("SSL server - Want Client Auth: "+sslServer.getWantClientAuth());
    388             Main.trace("SSL server - Use Client Mode: "+sslServer.getUseClientMode());
     384            Logging.trace("SSL server - Enabled Cipher suites: {0}", Arrays.toString(sslServer.getEnabledCipherSuites()));
     385            Logging.trace("SSL server - Enabled Protocols: {0}", Arrays.toString(sslServer.getEnabledProtocols()));
     386            Logging.trace("SSL server - Enable Session Creation: {0}", sslServer.getEnableSessionCreation());
     387            Logging.trace("SSL server - Need Client Auth: {0}", sslServer.getNeedClientAuth());
     388            Logging.trace("SSL server - Want Client Auth: {0}", sslServer.getWantClientAuth());
     389            Logging.trace("SSL server - Use Client Mode: {0}", sslServer.getUseClientMode());
    389390        }
    390391    }
     
    395396    @Override
    396397    public void run() {
    397         Main.info(marktr("RemoteControl::Accepting secure remote connections on {0}:{1}"),
     398        Logging.info(marktr("RemoteControl::Accepting secure remote connections on {0}:{1}"),
    398399                server.getInetAddress(), Integer.toString(server.getLocalPort()));
    399400        while (true) {
     
    401402                @SuppressWarnings("resource")
    402403                Socket request = server.accept();
    403                 if (Main.isTraceEnabled() && request instanceof SSLSocket) {
     404                if (Logging.isTraceEnabled() && request instanceof SSLSocket) {
    404405                    SSLSocket sslSocket = (SSLSocket) request;
    405                     Main.trace("SSL socket - Enabled Cipher suites: "+Arrays.toString(sslSocket.getEnabledCipherSuites()));
    406                     Main.trace("SSL socket - Enabled Protocols: "+Arrays.toString(sslSocket.getEnabledProtocols()));
    407                     Main.trace("SSL socket - Enable Session Creation: "+sslSocket.getEnableSessionCreation());
    408                     Main.trace("SSL socket - Need Client Auth: "+sslSocket.getNeedClientAuth());
    409                     Main.trace("SSL socket - Want Client Auth: "+sslSocket.getWantClientAuth());
    410                     Main.trace("SSL socket - Use Client Mode: "+sslSocket.getUseClientMode());
    411                     Main.trace("SSL socket - Session: "+sslSocket.getSession());
     406                    Logging.trace("SSL socket - Enabled Cipher suites: {0}", Arrays.toString(sslSocket.getEnabledCipherSuites()));
     407                    Logging.trace("SSL socket - Enabled Protocols: {0}", Arrays.toString(sslSocket.getEnabledProtocols()));
     408                    Logging.trace("SSL socket - Enable Session Creation: {0}", sslSocket.getEnableSessionCreation());
     409                    Logging.trace("SSL socket - Need Client Auth: {0}", sslSocket.getNeedClientAuth());
     410                    Logging.trace("SSL socket - Want Client Auth: {0}", sslSocket.getWantClientAuth());
     411                    Logging.trace("SSL socket - Use Client Mode: {0}", sslSocket.getUseClientMode());
     412                    Logging.trace("SSL socket - Session: {0}", sslSocket.getSession());
    412413                }
    413414                RequestProcessor.processRequest(request);
    414415            } catch (SocketException e) {
    415416                if (!server.isClosed()) {
    416                     Main.error(e);
     417                    Logging.error(e);
    417418                }
    418419            } catch (IOException ioe) {
    419                 Main.error(ioe);
     420                Logging.error(ioe);
    420421            }
    421422        }
     
    428429     */
    429430    public void stopServer() throws IOException {
    430         Main.info(marktr("RemoteControl::Server {0}:{1} stopped."),
     431        Logging.info(marktr("RemoteControl::Server {0}:{1} stopped."),
    431432        server.getInetAddress(), Integer.toString(server.getLocalPort()));
    432433        server.close();
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/RequestProcessor.java

    r11952 r12620  
    2525import java.util.regex.Pattern;
    2626
    27 import org.openstreetmap.josm.Main;
    2827import org.openstreetmap.josm.gui.help.HelpUtil;
    2928import org.openstreetmap.josm.io.remotecontrol.handler.AddNodeHandler;
     
    4140import org.openstreetmap.josm.io.remotecontrol.handler.RequestHandler.RequestHandlerForbiddenException;
    4241import org.openstreetmap.josm.io.remotecontrol.handler.VersionHandler;
     42import org.openstreetmap.josm.tools.Logging;
    4343import org.openstreetmap.josm.tools.Utils;
    4444
     
    119119        String commandWithSlash = '/' + command;
    120120        if (handlers.get(commandWithSlash) != null) {
    121             Main.info("RemoteControl: ignoring duplicate command " + command
     121            Logging.info("RemoteControl: ignoring duplicate command " + command
    122122                    + " with handler " + handler.getName());
    123123        } else {
    124124            if (!silent) {
    125                 Main.info("RemoteControl: adding command \"" +
     125                Logging.info("RemoteControl: adding command \"" +
    126126                    command + "\" (handled by " + handler.getSimpleName() + ')');
    127127            }
     
    161161                return;
    162162            }
    163             Main.info("RemoteControl received: " + get);
     163            Logging.info("RemoteControl received: " + get);
    164164
    165165            StringTokenizer st = new StringTokenizer(get);
     
    247247                    out.flush();
    248248                } catch (RequestHandlerErrorException ex) {
    249                     Main.debug(ex);
     249                    Logging.debug(ex);
    250250                    sendError(out);
    251251                } catch (RequestHandlerBadRequestException ex) {
    252                     Main.debug(ex);
     252                    Logging.debug(ex);
    253253                    sendBadRequest(out, ex.getMessage());
    254254                } catch (RequestHandlerForbiddenException ex) {
    255                     Main.debug(ex);
     255                    Logging.debug(ex);
    256256                    sendForbidden(out, ex.getMessage());
    257257                }
     
    259259
    260260        } catch (IOException ioe) {
    261             Main.debug(Main.getErrorMessage(ioe));
     261            Logging.debug(Logging.getErrorMessage(ioe));
    262262        } catch (ReflectiveOperationException e) {
    263             Main.error(e);
     263            Logging.error(e);
    264264            try {
    265265                sendError(out);
    266266            } catch (IOException e1) {
    267                 Main.warn(e1);
     267                Logging.warn(e1);
    268268            }
    269269        } finally {
     
    271271                request.close();
    272272            } catch (IOException e) {
    273                 Main.debug(Main.getErrorMessage(e));
     273                Logging.debug(Logging.getErrorMessage(e));
    274274            }
    275275        }
     
    402402                handler = handlers.get(cmd).getConstructor().newInstance();
    403403            } catch (ReflectiveOperationException ex) {
    404                 Main.error(ex);
     404                Logging.error(ex);
    405405                return null;
    406406            }
     
    410410            return w.toString();
    411411        } catch (IOException e) {
    412             Main.error(e);
     412            Logging.error(e);
    413413            return null;
    414414        }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/AddNodeHandler.java

    r10716 r12620  
    1717import org.openstreetmap.josm.io.remotecontrol.AddTagsDialog;
    1818import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    7778
    7879        // Parse the arguments
    79         Main.info("Adding node at (" + lat + ", " + lon + ')');
     80        Logging.info("Adding node at (" + lat + ", " + lon + ')');
    8081
    8182        // Create a new node
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/FeaturesHandler.java

    r11567 r12620  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import org.openstreetmap.josm.Main;
    76import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
    87import org.openstreetmap.josm.io.remotecontrol.RequestProcessor;
     8import org.openstreetmap.josm.tools.Logging;
    99
    1010/**
     
    3737                   buf.append(info);
    3838               } else {
    39                    Main.warn("Unknown handler {0} passed to /features request", s);
     39                   Logging.warn("Unknown handler {0} passed to /features request", s);
    4040               }
    4141            }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/ImageryHandler.java

    r10728 r12620  
    1313import org.openstreetmap.josm.gui.util.GuiHelper;
    1414import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     15import org.openstreetmap.josm.tools.Logging;
    1516import org.openstreetmap.josm.tools.Utils;
    1617
     
    7778                imgInfo.setDefaultMinZoom(Integer.parseInt(minZoom));
    7879            } catch (NumberFormatException e) {
    79                 Main.error(e);
     80                Logging.error(e);
    8081            }
    8182        }
     
    8586                imgInfo.setDefaultMaxZoom(Integer.parseInt(maxZoom));
    8687            } catch (NumberFormatException e) {
    87                 Main.error(e);
     88                Logging.error(e);
    8889            }
    8990        }
     
    9798            for (ImageryLayer layer : Main.getLayerManager().getLayersOfType(ImageryLayer.class)) {
    9899                if (layer.getInfo().equals(imgInfo)) {
    99                     Main.info("Imagery layer already exists: "+imgInfo);
     100                    Logging.info("Imagery layer already exists: "+imgInfo);
    100101                    return;
    101102                }
     
    106107                Main.getLayerManager().addLayer(ImageryLayer.create(imgInfo));
    107108            } catch (IllegalArgumentException e) {
    108                 Main.error(e, false);
     109                Logging.log(Logging.LEVEL_ERROR, e);
    109110            }
    110111        });
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/ImportHandler.java

    r11746 r12620  
    1414import org.openstreetmap.josm.actions.downloadtasks.DownloadTask;
    1515import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     16import org.openstreetmap.josm.tools.Logging;
    1617import org.openstreetmap.josm.tools.Utils;
    1718
     
    3637                // For compatibility reasons with older instances of JOSM, arbitrary choice of DownloadOsmTask
    3738                // As of 2015-04, Overpass Turbo requires this branch of code ...
    38                 Main.debug("Remote control, /import: defaulting to DownloadOsmTask");
     39                Logging.debug("Remote control, /import: defaulting to DownloadOsmTask");
    3940                new DownloadOsmTask().loadUrl(isLoadInNewLayer(), url.toExternalForm(), null);
    4041            } else if (Main.pref.getBoolean("remotecontrol.import.interactive", true)) {
     
    4849            }
    4950        } catch (RuntimeException ex) { // NOPMD
    50             Main.warn("RemoteControl: Error parsing import remote control request:");
    51             Main.error(ex);
     51            Logging.warn("RemoteControl: Error parsing import remote control request:");
     52            Logging.error(ex);
    5253            throw new RequestHandlerErrorException(ex);
    5354        }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/LoadAndZoomHandler.java

    r12472 r12620  
    2929import org.openstreetmap.josm.io.remotecontrol.AddTagsDialog;
    3030import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     31import org.openstreetmap.josm.tools.Logging;
    3132import org.openstreetmap.josm.tools.SubclassFilteredCollection;
    3233import org.openstreetmap.josm.tools.Utils;
     
    114115            if (command.equals(myCommand)) {
    115116                if (!PermissionPrefWithDefault.LOAD_DATA.isAllowed()) {
    116                     Main.info("RemoteControl: download forbidden by preferences");
     117                    Logging.info("RemoteControl: download forbidden by preferences");
    117118                } else {
    118119                    Area toDownload = null;
     
    138139                    }
    139140                    if (toDownload != null && toDownload.isEmpty()) {
    140                         Main.info("RemoteControl: no download necessary");
     141                        Logging.info("RemoteControl: no download necessary");
    141142                    } else {
    142143                        Future<?> future = osmTask.download(newLayer, new Bounds(minlat, minlon, maxlat, maxlon),
     
    147148            }
    148149        } catch (RuntimeException ex) { // NOPMD
    149             Main.warn("RemoteControl: Error parsing load_and_zoom remote control request:");
    150             Main.error(ex);
     150            Logging.warn("RemoteControl: Error parsing load_and_zoom remote control request:");
     151            Logging.error(ex);
    151152            throw new RequestHandlerErrorException(ex);
    152153        }
     
    200201                });
    201202            } catch (SearchCompiler.ParseError ex) {
    202                 Main.error(ex);
     203                Logging.error(ex);
    203204                throw new RequestHandlerErrorException(ex);
    204205            }
     
    284285                        toSelect.add(SimplePrimitiveId.fromString(item));
    285286                    } catch (IllegalArgumentException ex) {
    286                         Main.warn(ex, "RemoteControl: invalid selection '" + item + "' ignored");
     287                        Logging.log(Logging.LEVEL_WARN, "RemoteControl: invalid selection '" + item + "' ignored", ex);
    287288                    }
    288289                }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/LoadObjectHandler.java

    r12472 r12620  
    1818import org.openstreetmap.josm.io.remotecontrol.AddTagsDialog;
    1919import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     20import org.openstreetmap.josm.tools.Logging;
    2021
    2122/**
     
    5960    protected void handleRequest() throws RequestHandlerErrorException, RequestHandlerBadRequestException {
    6061        if (!PermissionPrefWithDefault.LOAD_DATA.isAllowed()) {
    61             Main.info("RemoteControl: download forbidden by preferences");
     62            Logging.info("RemoteControl: download forbidden by preferences");
    6263        }
    6364        if (!ps.isEmpty()) {
     
    102103                    ps.add(SimplePrimitiveId.fromString(i));
    103104                } catch (IllegalArgumentException e) {
    104                     Main.warn(e, "RemoteControl: invalid selection '"+i+"' ignored.");
     105                    Logging.log(Logging.LEVEL_WARN, "RemoteControl: invalid selection '"+i+"' ignored.", e);
    105106                }
    106107            }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/RequestHandler.java

    r11567 r12620  
    2020import org.openstreetmap.josm.Main;
    2121import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     22import org.openstreetmap.josm.tools.Logging;
    2223import org.openstreetmap.josm.tools.Utils;
    2324
     
    148149        if (permissionPref != null && permissionPref.pref != null && !Main.pref.getBoolean(permissionPref.pref, permissionPref.defaultVal)) {
    149150            String err = MessageFormat.format("RemoteControl: ''{0}'' forbidden by preferences", myCommand);
    150             Main.info(err);
     151            Logging.info(err);
    151152            throw new RequestHandlerForbiddenException(err);
    152153        }
     
    228229                if (value == null || value.isEmpty()) {
    229230                    error = true;
    230                     Main.warn('\'' + myCommand + "' remote control request must have '" + key + "' parameter");
     231                    Logging.warn('\'' + myCommand + "' remote control request must have '" + key + "' parameter");
    231232                    missingKeys.add(key);
    232233                }
     
    241242            for (String par: args.keySet()) {
    242243                if (!knownParams.contains(par)) {
    243                     Main.warn("Unknown remote control parameter {0}, skipping it", par);
     244                    Logging.warn("Unknown remote control parameter {0}, skipping it", par);
    244245                }
    245246            }
  • trunk/src/org/openstreetmap/josm/io/session/GeoImageSessionExporter.java

    r9983 r12620  
    1212import javax.swing.SwingConstants;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.gui.layer.Layer;
    1615import org.openstreetmap.josm.gui.layer.geoimage.GeoImageLayer;
    1716import org.openstreetmap.josm.gui.layer.geoimage.ImageEntry;
    1817import org.openstreetmap.josm.tools.GBC;
     18import org.openstreetmap.josm.tools.Logging;
    1919import org.w3c.dom.Element;
    2020
     
    6666
    6767            if (entry.getFile() == null) {
    68                 Main.warn("No file attribute for image - skipping entry");
     68                Logging.warn("No file attribute for image - skipping entry");
    6969                break;
    7070            }
  • trunk/src/org/openstreetmap/josm/io/session/GeoImageSessionImporter.java

    r11522 r12620  
    1010import java.util.List;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.coor.LatLon;
    1413import org.openstreetmap.josm.gui.layer.GpxLayer;
     
    1817import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1918import org.openstreetmap.josm.io.IllegalDataException;
     19import org.openstreetmap.josm.tools.Logging;
    2020import org.w3c.dom.Element;
    2121import org.w3c.dom.Node;
     
    117117            // TODO: handle thumbnail loading
    118118        } catch (NumberFormatException e) {
    119             Main.trace(e);
     119            Logging.trace(e);
    120120        }
    121121    }
  • trunk/src/org/openstreetmap/josm/io/session/ImagerySessionImporter.java

    r12604 r12620  
    88import java.util.Map;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.Preferences;
    1211import org.openstreetmap.josm.data.imagery.ImageryInfo;
     
    2322import org.openstreetmap.josm.io.IllegalDataException;
    2423import org.openstreetmap.josm.io.session.SessionReader.ImportSupport;
     24import org.openstreetmap.josm.tools.Logging;
    2525import org.openstreetmap.josm.tools.Utils;
    2626import org.w3c.dom.Element;
     
    5050                String zoomStr = attributes.get("zoom-level");
    5151                if (zoomStr != null) {
    52                         support.addPostLayersTask(() -> {
    53                             try {
    54                                 tsLayer.setZoomLevel(Integer.parseInt(zoomStr));
    55                             } catch (NumberFormatException e) {
    56                                 Main.warn(e);
    57                             }
    58                         });
     52                    support.addPostLayersTask(() -> {
     53                        try {
     54                            tsLayer.setZoomLevel(Integer.parseInt(zoomStr));
     55                        } catch (NumberFormatException e) {
     56                            Logging.warn(e);
     57                        }
     58                    });
    5959                }
    6060            }
  • trunk/src/org/openstreetmap/josm/io/session/SessionReader.java

    r12542 r12620  
    4545import org.openstreetmap.josm.tools.CheckParameterUtil;
    4646import org.openstreetmap.josm.tools.JosmRuntimeException;
     47import org.openstreetmap.josm.tools.Logging;
    4748import org.openstreetmap.josm.tools.MultiMap;
    4849import org.openstreetmap.josm.tools.Utils;
     
    447448            active = !activeAtt.isEmpty() ? (Integer.parseInt(activeAtt)-1) : -1;
    448449        } catch (NumberFormatException e) {
    449             Main.warn("Unsupported value for 'active' layer attribute. Ignoring it. Error was: "+e.getMessage());
     450            Logging.warn("Unsupported value for 'active' layer attribute. Ignoring it. Error was: "+e.getMessage());
    450451            active = -1;
    451452        }
     
    468469                        idx = Integer.valueOf(e.getAttribute("index"));
    469470                    } catch (NumberFormatException ex) {
    470                         Main.warn(ex);
     471                        Logging.warn(ex);
    471472                    }
    472473                    if (idx == null) {
     
    485486                                d = Integer.valueOf(sd);
    486487                            } catch (NumberFormatException ex) {
    487                                 Main.warn(ex);
     488                                Logging.warn(ex);
    488489                            }
    489490                            if (d != null) {
     
    567568                }
    568569                if (exception != null) {
    569                     Main.error(exception);
     570                    Logging.error(exception);
    570571                    if (!GraphicsEnvironment.isHeadless()) {
    571572                        CancelOrContinueDialog dialog = new CancelOrContinueDialog();
     
    607608                    layer.setOpacity(opacity);
    608609                } catch (NumberFormatException ex) {
    609                     Main.warn(ex);
     610                    Logging.warn(ex);
    610611                }
    611612            }
     
    625626                    Double.parseDouble(centerEl.getAttribute("lon")));
    626627        } catch (NumberFormatException ex) {
    627             Main.warn(ex);
     628            Logging.warn(ex);
    628629        }
    629630        if (center == null) return null;
     
    634635            return new SessionViewportData(center, scale);
    635636        } catch (NumberFormatException ex) {
    636             Main.warn(ex);
     637            Logging.warn(ex);
    637638            return null;
    638639        }
  • trunk/src/org/openstreetmap/josm/io/session/SessionWriter.java

    r12489 r12620  
    4343import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference;
    4444import org.openstreetmap.josm.tools.JosmRuntimeException;
     45import org.openstreetmap.josm.tools.Logging;
    4546import org.openstreetmap.josm.tools.MultiMap;
    4647import org.openstreetmap.josm.tools.Utils;
     
    241242                    int depIndex = layers.indexOf(depLayer);
    242243                    if (depIndex == -1) {
    243                         Main.warn("Unable to find " + depLayer);
     244                        Logging.warn("Unable to find " + depLayer);
    244245                    } else {
    245246                        depsInt.add(depIndex+1);
Note: See TracChangeset for help on using the changeset viewer.