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

Legend:

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

    r11984 r12620  
    2626import org.openstreetmap.josm.io.OsmTransferException;
    2727import org.openstreetmap.josm.tools.ExceptionUtil;
     28import org.openstreetmap.josm.tools.Logging;
    2829import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    2930
     
    9293     */
    9394    public static void explainGeneric(Exception e) {
    94         Main.error(e);
     95        Logging.error(e);
    9596        BugReportExceptionHandler.handleException(e);
    9697    }
  • trunk/src/org/openstreetmap/josm/gui/ExtendedDialog.java

    r11945 r12620  
    4141import org.openstreetmap.josm.tools.ImageProvider;
    4242import org.openstreetmap.josm.tools.InputMapUtils;
     43import org.openstreetmap.josm.tools.Logging;
    4344import org.openstreetmap.josm.tools.Utils;
    4445import org.openstreetmap.josm.tools.WindowGeometry;
     
    413414                // and the result differs from its default value
    414415                result = ExtendedDialog.DialogClosedOtherwise;
    415                 if (Main.isDebugEnabled()) {
    416                     Main.debug(getClass().getName()+" ESC action performed ("+actionEvent+") from "+new Exception().getStackTrace()[1]);
     416                if (Logging.isDebugEnabled()) {
     417                    Logging.debug("{0} ESC action performed ({1}) from {2}",
     418                            getClass().getName(), actionEvent, new Exception().getStackTrace()[1]);
    417419                }
    418420                setVisible(false);
     
    442444        }
    443445
    444         if (Main.isDebugEnabled()) {
    445             Main.debug(getClass().getName()+".setVisible("+visible+") from "+new Exception().getStackTrace()[1]);
     446        if (Logging.isDebugEnabled()) {
     447            Logging.debug(getClass().getName()+".setVisible("+visible+") from "+new Exception().getStackTrace()[1]);
    446448        }
    447449
  • trunk/src/org/openstreetmap/josm/gui/GettingStarted.java

    r12259 r12620  
    3030import org.openstreetmap.josm.io.OnlineResource;
    3131import org.openstreetmap.josm.tools.LanguageInfo;
     32import org.openstreetmap.josm.tools.Logging;
    3233import org.openstreetmap.josm.tools.OpenBrowser;
    3334import org.openstreetmap.josm.tools.WikiReader;
     
    3536/**
    3637 * Panel that fills the main part of the program window when JOSM has just started.
    37  * 
     38 *
    3839 * It downloads and displays the so called <em>message of the day</em>, which
    3940 * contains news about recent major changes, warning in case of outdated versions, etc.
     
    151152                    ProxyPreference.removeProxyPreferenceListener(this);
    152153                } catch (IOException ex) {
    153                     Main.warn(ex, tr("Failed to read MOTD. Exception was: {0}", ex.toString()));
     154                    Logging.log(Logging.LEVEL_WARN, tr("Failed to read MOTD. Exception was: {0}", ex.toString()), ex);
    154155                    content = "<html>" + STYLE + "<h1>" + "JOSM - " + tr("Java OpenStreetMap Editor")
    155156                            + "</h1>\n<h2 align=\"center\">(" + tr("Message of the day not available") + ")</h2></html>";
  • trunk/src/org/openstreetmap/josm/gui/HelpAwareOptionPane.java

    r12391 r12620  
    2424import javax.swing.event.ChangeListener;
    2525
    26 import org.openstreetmap.josm.Main;
    2726import org.openstreetmap.josm.gui.help.HelpBrowser;
    2827import org.openstreetmap.josm.gui.help.HelpUtil;
     
    3130import org.openstreetmap.josm.tools.ImageProvider;
    3231import org.openstreetmap.josm.tools.InputMapUtils;
     32import org.openstreetmap.josm.tools.Logging;
    3333import org.openstreetmap.josm.tools.WindowGeometry;
    3434
     
    253253        switch (messageType) {
    254254            case JOptionPane.ERROR_MESSAGE:
    255                 Main.error(title + " - " + msg);
     255                Logging.error(title + " - " + msg);
    256256                break;
    257257            case JOptionPane.WARNING_MESSAGE:
    258                 Main.warn(title + " - " + msg);
     258                Logging.warn(title + " - " + msg);
    259259                break;
    260260            default:
    261                 Main.info(title + " - " + msg);
     261                Logging.info(title + " - " + msg);
    262262        }
    263263
  • trunk/src/org/openstreetmap/josm/gui/JosmUserIdentityManager.java

    r11906 r12620  
    2121import org.openstreetmap.josm.tools.CheckParameterUtil;
    2222import org.openstreetmap.josm.tools.JosmRuntimeException;
     23import org.openstreetmap.josm.tools.Logging;
    2324
    2425/**
     
    6869                    instance.initFromOAuth();
    6970                } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    70                     Main.error(e);
     71                    Logging.error(e);
    7172                    // Fall back to preferences if OAuth identification fails for any reason
    7273                    instance.initFromPreferences();
     
    231232            setFullyIdentified(info.getDisplayName(), info);
    232233        } catch (IllegalArgumentException | OsmTransferException e) {
    233             Main.error(e);
     234            Logging.error(e);
    234235        }
    235236    }
  • trunk/src/org/openstreetmap/josm/gui/MainApplication.java

    r12279 r12620  
    223223        Logging.setLogLevel(logLevel);
    224224        if (!args.showVersion() && !args.showHelp()) {
    225             Main.info(tr("Log level is at {0} ({1}, {2})", logLevel.getLocalizedName(), logLevel.getName(), logLevel.intValue()));
     225            Logging.info(tr("Log level is at {0} ({1}, {2})", logLevel.getLocalizedName(), logLevel.getName(), logLevel.intValue()));
    226226        }
    227227
     
    263263        boolean skipLoadingPlugins = args.hasOption(Option.SKIP_PLUGINS);
    264264        if (skipLoadingPlugins) {
    265             Main.info(tr("Plugin loading skipped"));
     265            Logging.info(tr("Plugin loading skipped"));
    266266        }
    267267
     
    269269            // Enable debug in OAuth signpost via system preference, but only at trace level
    270270            Utils.updateSystemProperty("debug", "true");
    271             Main.info(tr("Enabled detailed debug level (trace)"));
     271            Logging.info(tr("Enabled detailed debug level (trace)"));
    272272        }
    273273
     
    306306            CustomConfigurator.XMLCommandProcessor config = new CustomConfigurator.XMLCommandProcessor(Main.pref);
    307307            for (String i : args.get(Option.LOAD_PREFERENCES)) {
    308                 info("Reading preferences from " + i);
     308                Logging.info("Reading preferences from " + i);
    309309                try (InputStream is = openStream(new URL(i))) {
    310310                    config.openAndReadXML(is);
     
    318318            CertificateAmendment.addMissingCertificates();
    319319        } catch (IOException | GeneralSecurityException ex) {
    320             Main.warn(ex);
    321             Main.warn(getErrorMessage(Utils.getRootCause(ex)));
     320            Logging.warn(ex);
     321            Logging.warn(Logging.getErrorMessage(Utils.getRootCause(ex)));
    322322        }
    323323        Authenticator.setDefault(DefaultAuthenticator.getInstance());
     
    387387                PlatformHookWindows.removeInsecureCertificates();
    388388            } catch (NoSuchAlgorithmException | CertificateException | KeyStoreException | IOException e) {
    389                 error(e);
     389                Logging.error(e);
    390390            }
    391391        }
     
    402402            // Repaint manager is registered so late for a reason - there is lots of violation during startup process
    403403            // but they don't seem to break anything and are difficult to fix
    404             info("Enabled EDT checker, wrongful access to gui from non EDT thread will be printed to console");
     404            Logging.info("Enabled EDT checker, wrongful access to gui from non EDT thread will be printed to console");
    405405            RepaintManager.setCurrentManager(new CheckThreadViolationRepaintManager());
    406406        }
     
    443443                    Main.setOffline(OnlineResource.valueOf(s.toUpperCase(Locale.ENGLISH)));
    444444                } catch (IllegalArgumentException e) {
    445                     Main.error(e, tr("''{0}'' is not a valid value for argument ''{1}''. Possible values are {2}, possibly delimited by commas.",
    446                             s.toUpperCase(Locale.ENGLISH), Option.OFFLINE.getName(), Arrays.toString(OnlineResource.values())));
     445                    Logging.log(Logging.LEVEL_ERROR,
     446                            tr("''{0}'' is not a valid value for argument ''{1}''. Possible values are {2}, possibly delimited by commas.",
     447                            s.toUpperCase(Locale.ENGLISH), Option.OFFLINE.getName(), Arrays.toString(OnlineResource.values())), e);
    447448                    System.exit(1);
    448449                    return;
     
    452453        Set<OnlineResource> offline = Main.getOfflineResources();
    453454        if (!offline.isEmpty()) {
    454             Main.warn(trn("JOSM is running in offline mode. This resource will not be available: {0}",
     455            Logging.warn(trn("JOSM is running in offline mode. This resource will not be available: {0}",
    455456                    "JOSM is running in offline mode. These resources will not be available: {0}",
    456457                    offline.size(), offline.size() == 1 ? offline.iterator().next() : Arrays.toString(offline.toArray())));
     
    480481                                Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true");
    481482                                if (!wasv6) {
    482                                     Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4 after next restart."));
     483                                    Logging.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4 after next restart."));
    483484                                } else {
    484                                     Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4."));
     485                                    Logging.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4."));
    485486                                }
    486487                                hasv6 = true;
     
    490491                    }
    491492                } catch (IOException | SecurityException e) {
    492                     if (Main.isDebugEnabled()) {
    493                         Main.debug("Exception while checking IPv6 connectivity: "+e);
    494                     }
    495                     Main.trace(e);
     493                    Logging.debug("Exception while checking IPv6 connectivity: {0}", e);
     494                    Logging.trace(e);
    496495                }
    497496                if (wasv6 && !hasv6) {
    498                     Main.info(tr("Detected no useable IPv6 network, prefering IPv4 over IPv6 after next restart."));
     497                    Logging.info(tr("Detected no useable IPv6 network, prefering IPv4 over IPv6 after next restart."));
    499498                    Main.pref.put("validated.ipv6", hasv6); // be sure it is stored before the restart!
    500499                    try {
    501500                        RestartAction.restartJOSM();
    502501                    } catch (IOException e) {
    503                         Main.error(e);
     502                        Logging.error(e);
    504503                    }
    505504                }
  • trunk/src/org/openstreetmap/josm/gui/MainFrame.java

    r12128 r12620  
    2828import org.openstreetmap.josm.gui.layer.OsmDataLayer.LayerStateChangeListener;
    2929import org.openstreetmap.josm.tools.ImageProvider;
     30import org.openstreetmap.josm.tools.Logging;
    3031import org.openstreetmap.josm.tools.WindowGeometry;
    3132
     
    144145                setExtendedState(windowState);
    145146            } else {
    146                 Main.debug("Main window: maximizing not supported");
     147                Logging.debug("Main window: maximizing not supported");
    147148            }
    148149        } else {
  • trunk/src/org/openstreetmap/josm/gui/MapStatus.java

    r12391 r12620  
    7979import org.openstreetmap.josm.tools.GBC;
    8080import org.openstreetmap.josm.tools.ImageProvider;
     81import org.openstreetmap.josm.tools.Logging;
    8182import org.openstreetmap.josm.tools.Utils;
    8283
     
    203204        public void appendLogMessage(String message) {
    204205            if (message != null && !message.isEmpty()) {
    205                 Main.info("appendLogMessage not implemented for background tasks. Message was: " + message);
     206                Logging.info("appendLogMessage not implemented for background tasks. Message was: " + message);
    206207            }
    207208        }
     
    357358                    oldMousePos = ms.mousePos;
    358359                } catch (ConcurrentModificationException ex) {
    359                     Main.warn(ex);
     360                    Logging.warn(ex);
    360361                } finally {
    361362                    if (ds != null) {
     
    415416                        EventQueue.invokeAndWait(new CollectorWorker(ms));
    416417                    } catch (InvocationTargetException e) {
    417                         Main.warn(e);
     418                        Logging.warn(e);
    418419                    }
    419420                }
    420421            } catch (InterruptedException e) {
    421422                // Occurs frequently during JOSM shutdown, log set to trace only
    422                 Main.trace("InterruptedException in "+MapStatus.class.getSimpleName());
     423                Logging.trace("InterruptedException in "+MapStatus.class.getSimpleName());
    423424                Thread.currentThread().interrupt();
    424425            } finally {
     
    686687            incomingMouseState.clear();
    687688            if (!incomingMouseState.offer(ms)) {
    688                 Main.warn("Unable to handle new MouseState: " + ms);
     689                Logging.warn("Unable to handle new MouseState: " + ms);
    689690            }
    690691        }
     
    739740                    AWTEvent.KEY_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
    740741        } catch (SecurityException ex) {
    741             Main.trace(ex);
     742            Logging.trace(ex);
    742743            mv.addMouseMotionListener(mouseMotionListener);
    743744            mv.addKeyListener(keyAdapter);
     
    750751        } catch (SecurityException e) {
    751752            // Don't care, awtListener probably wasn't registered anyway
    752             Main.trace(e);
     753            Logging.trace(e);
    753754        }
    754755        mv.removeMouseMotionListener(mouseMotionListener);
     
    11111112                thread.interrupt();
    11121113            } catch (SecurityException e) {
    1113                 Main.error(e);
     1114                Logging.error(e);
    11141115            }
    11151116        }
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r12400 r12620  
    174174        public void paint(MapViewGraphics graphics) {
    175175            if (!warningPrinted) {
    176                 Main.debug("A layer triggered a repaint while being added: " + layer);
     176                Logging.debug("A layer triggered a repaint while being added: " + layer);
    177177                warningPrinted = true;
    178178            }
     
    337337            if (!registeredLayers.containsKey(layer)) {
    338338                // The layer may have removed itself during attachToMapView()
    339                 Main.warn("Layer was removed during attachToMapView()");
     339                Logging.warn("Layer was removed during attachToMapView()");
    340340            } else {
    341341                registeredLayers.put(layer, painter);
     
    385385        LayerPainter painter = registeredLayers.remove(layer);
    386386        if (painter == null) {
    387             Main.error("The painter for layer " + layer + " was not registered.");
     387            Logging.error("The painter for layer " + layer + " was not registered.");
    388388            return;
    389389        }
     
    414414     * Checks if virtual nodes should be drawn. Default is <code>false</code>
    415415     * @return The virtual nodes property.
    416      * @see Rendering#render(DataSet, boolean, Bounds)
     416     * @see Rendering#render
    417417     */
    418418    public boolean isVirtualNodesEnabled() {
     
    598598            //
    599599            // But the application seems to work fine after, so let's just log the error
    600             Main.error(e);
     600            Logging.error(e);
    601601        }
    602602    }
     
    843843    @Override
    844844    public void repaint() {
    845         if (Main.isTraceEnabled()) {
     845        if (Logging.isTraceEnabled()) {
    846846            invalidatedListener.traceRandomRepaint();
    847847        }
  • trunk/src/org/openstreetmap/josm/gui/MenuScroller.java

    r12234 r12620  
    2929
    3030import org.openstreetmap.josm.Main;
     31import org.openstreetmap.josm.tools.Logging;
    3132import org.openstreetmap.josm.tools.WindowGeometry;
    3233
     
    464465            firstIndex += mwe.getWheelRotation();
    465466            refreshMenu();
    466             if (Main.isDebugEnabled()) {
    467                 Main.debug(getClass().getName()+" consuming event "+mwe);
     467            if (Logging.isDebugEnabled()) {
     468                Logging.debug("{0} consuming event {1}", getClass().getName(), mwe);
    468469            }
    469470            mwe.consume();
  • trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r12163 r12620  
    6161import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
    6262import org.openstreetmap.josm.gui.util.CursorManager;
     63import org.openstreetmap.josm.tools.Logging;
    6364import org.openstreetmap.josm.tools.Utils;
    6465
     
    718719                            Thread.sleep(1000L / fps);
    719720                        } catch (InterruptedException ex) {
    720                             Main.warn("InterruptedException in "+NavigatableComponent.class.getSimpleName()+" during smooth scrolling");
     721                            Logging.warn("InterruptedException in "+NavigatableComponent.class.getSimpleName()+" during smooth scrolling");
    721722                            Thread.currentThread().interrupt();
    722723                        }
  • trunk/src/org/openstreetmap/josm/gui/NoteSortDialog.java

    r12540 r12620  
    1313import javax.swing.JRadioButton;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.notes.Note;
     16import org.openstreetmap.josm.tools.Logging;
    1717
    1818/**
     
    5151            lastActionSort.setSelected(true);
    5252        } else {
    53             Main.warn("sort mode not recognized");
     53            Logging.warn("sort mode not recognized");
    5454        }
    5555
  • trunk/src/org/openstreetmap/josm/gui/OsmPrimitivRenderer.java

    r10889 r12620  
    1313import javax.swing.table.TableCellRenderer;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1716import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
    1817import org.openstreetmap.josm.tools.ImageProvider;
     18import org.openstreetmap.josm.tools.Logging;
    1919
    2020/**
     
    8282                ((JLabel) def).setIcon(icon);
    8383            } else {
    84                 Main.warn("Null icon for "+value.getDisplayType());
     84                Logging.warn("Null icon for "+value.getDisplayType());
    8585            }
    8686            ((JLabel) def).setToolTipText(getComponentToolTipText(value));
  • trunk/src/org/openstreetmap/josm/gui/SideButton.java

    r10755 r12620  
    1717import javax.swing.plaf.basic.BasicArrowButton;
    1818
    19 import org.openstreetmap.josm.Main;
    2019import org.openstreetmap.josm.tools.Destroyable;
    2120import org.openstreetmap.josm.tools.ImageProvider;
    2221import org.openstreetmap.josm.tools.ImageResource;
     22import org.openstreetmap.josm.tools.Logging;
    2323
    2424/**
     
    4242                ImageProvider.ImageSizes.SIDEBUTTON.getImageDimension()));
    4343        } else if (getIcon() != null) { /* TODO: remove when calling code is fixed, replace by exception */
    44             Main.warn("Old style SideButton usage for action " + action);
     44            Logging.warn("Old style SideButton usage for action " + action);
    4545            fixIcon(action);
    4646        }
  • trunk/src/org/openstreetmap/josm/gui/SplashScreen.java

    r12405 r12620  
    4040import org.openstreetmap.josm.tools.GBC;
    4141import org.openstreetmap.josm.tools.ImageProvider;
     42import org.openstreetmap.josm.tools.Logging;
    4243import org.openstreetmap.josm.tools.Utils;
    4344import org.openstreetmap.josm.tools.WindowGeometry;
     
    233234        public void beginTask(String title) {
    234235            if (title != null && !title.isEmpty()) {
    235                 if (Main.isDebugEnabled()) {
    236                     Main.debug(title);
    237                 }
     236                Logging.debug(title);
    238237                final MeasurableTask task = new MeasurableTask(title);
    239238                tasks.add(task);
     
    264263        @Override
    265264        public void subTask(String title) {
    266             if (Main.isDebugEnabled()) {
    267                 Main.debug(title);
    268             }
     265            Logging.debug(title);
    269266            latestSubtask = new SplashProgressMonitor(title, listener);
    270267            tasks.add(latestSubtask);
     
    299296            if (task instanceof MeasurableTask) {
    300297                ((MeasurableTask) task).finish();
    301                 if (Main.isDebugEnabled()) {
    302                     Main.debug(tr("{0} completed in {1}", title, ((MeasurableTask) task).duration));
     298                if (Logging.isDebugEnabled()) {
     299                    Logging.debug(tr("{0} completed in {1}", title, ((MeasurableTask) task).duration));
    303300                }
    304301                listener.stateChanged(null);
  • trunk/src/org/openstreetmap/josm/gui/autofilter/AutoFilterManager.java

    r12480 r12620  
    5454import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
    5555import org.openstreetmap.josm.gui.widgets.OSDLabel;
     56import org.openstreetmap.josm.tools.Logging;
    5657
    5758/**
     
    182183                values.add(s);
    183184            } catch (NumberFormatException e) {
    184                 Main.trace(e);
     185                Logging.trace(e);
    185186            }
    186187        }
  • trunk/src/org/openstreetmap/josm/gui/bbox/SlippyMapBBoxChooser.java

    r12339 r12620  
    4444import org.openstreetmap.josm.gui.layer.AbstractCachedTileSourceLayer;
    4545import org.openstreetmap.josm.gui.layer.TMSLayer;
     46import org.openstreetmap.josm.tools.Logging;
    4647
    4748/**
     
    8687                    }
    8788                } catch (IllegalArgumentException ex) {
    88                     Main.warn(ex);
     89                    Logging.warn(ex);
    8990                    if (ex.getMessage() != null && !ex.getMessage().isEmpty()) {
    9091                        JOptionPane.showMessageDialog(Main.parent,
     
    134135     */
    135136    public SlippyMapBBoxChooser() {
    136         debug = Main.isDebugEnabled();
     137        debug = Logging.isDebugEnabled();
    137138        SpringLayout springLayout = new SpringLayout();
    138139        setLayout(springLayout);
  • trunk/src/org/openstreetmap/josm/gui/bbox/TileSelectionBBoxChooser.java

    r12131 r12620  
    6969 *            // listen for BBOX events
    7070 *            if (evt.getPropertyName().equals(BBoxChooser.BBOX_PROP)) {
    71  *               Main.info("new bbox based on OSM tiles selected: " + (Bounds)evt.getNewValue());
     71 *               Logging.info("new bbox based on OSM tiles selected: " + (Bounds)evt.getNewValue());
    7272 *            }
    7373 *        }
  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/AbstractListMergeModel.java

    r12151 r12620  
    4040import org.openstreetmap.josm.gui.widgets.OsmPrimitivesTableModel;
    4141import org.openstreetmap.josm.tools.CheckParameterUtil;
     42import org.openstreetmap.josm.tools.Logging;
    4243import org.openstreetmap.josm.tools.Utils;
    4344
     
    736737                return ((RelationMember) value).getMember();
    737738            } else {
    738                 Main.error("Unknown object type: "+value);
     739                Logging.error("Unknown object type: "+value);
    739740                return null;
    740741            }
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MultiValueCellEditor.java

    r10670 r12620  
    2121import javax.swing.table.TableCellEditor;
    2222
    23 import org.openstreetmap.josm.Main;
    2423import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     24import org.openstreetmap.josm.tools.Logging;
    2525
    2626/**
     
    167167            break;
    168168        default:
    169             Main.error("Unknown decision type in initEditor(): "+decision.getDecisionType());
     169            Logging.error("Unknown decision type in initEditor(): "+decision.getDecisionType());
    170170        }
    171171    }
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MultiValueCellRenderer.java

    r9243 r12620  
    1414import javax.swing.table.TableCellRenderer;
    1515
    16 import org.openstreetmap.josm.Main;
    1716import org.openstreetmap.josm.gui.conflict.ConflictColors;
    1817import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    1918import org.openstreetmap.josm.tools.ImageProvider;
     19import org.openstreetmap.josm.tools.Logging;
    2020
    2121/**
     
    7171                        break;
    7272                    default:
    73                         Main.error("Unknown decision type in renderColors(): "+decision.getDecisionType());
     73                        Logging.error("Unknown decision type in renderColors(): "+decision.getDecisionType());
    7474                    }
    7575                } else {
     
    103103            break;
    104104        default:
    105             Main.error("Unknown decision type in renderValue(): "+decision.getDecisionType());
     105            Logging.error("Unknown decision type in renderValue(): "+decision.getDecisionType());
    106106        }
    107107    }
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagConflictResolutionUtil.java

    r11606 r12620  
    2020import org.openstreetmap.josm.data.osm.Tag;
    2121import org.openstreetmap.josm.data.osm.TagCollection;
     22import org.openstreetmap.josm.tools.Logging;
    2223import org.openstreetmap.josm.tools.Pair;
    2324
     
    216217                    // Can happen if a particular resolver has an invalid regular expression pattern
    217218                    // but it should not stop the other automatic tag conflict resolution.
    218                     Main.error(e);
     219                    Logging.error(e);
    219220                }
    220221            }
  • trunk/src/org/openstreetmap/josm/gui/datatransfer/AbstractStackTransferHandler.java

    r11746 r12620  
    1515import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1616import org.openstreetmap.josm.tools.JosmRuntimeException;
     17import org.openstreetmap.josm.tools.Logging;
    1718import org.openstreetmap.josm.tools.bugreport.BugReport;
    1819
     
    5152            if (df.supports(support)) {
    5253                try {
    53                     if (Main.isDebugEnabled()) {
    54                         Main.debug("{0} pasting {1} at {2}", df.getClass().getSimpleName(), Arrays.toString(support.getDataFlavors()), center);
     54                    if (Logging.isDebugEnabled()) {
     55                        Logging.debug("{0} pasting {1} at {2}",
     56                                df.getClass().getSimpleName(), Arrays.toString(support.getDataFlavors()), center);
    5557                    }
    5658                    if (df.importData(support, layer, center)) {
     
    5860                    }
    5961                } catch (UnsupportedFlavorException | IOException e) {
    60                     Main.warn(e);
     62                    Logging.warn(e);
    6163                } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    6264                    BugReport.intercept(e).put("paster", df).put("flavors", support::getDataFlavors).warn();
  • trunk/src/org/openstreetmap/josm/gui/datatransfer/ClipboardUtils.java

    r11921 r12620  
    1313import java.io.IOException;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.gui.util.GuiHelper;
     16import org.openstreetmap.josm.tools.Logging;
    1717import org.openstreetmap.josm.tools.Utils;
    1818
     
    5050                clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    5151            } catch (HeadlessException e) {
    52                 Main.warn("Headless. Using fake clipboard.", e);
     52                Logging.warn("Headless. Using fake clipboard.", e);
    5353                clipboard = new Clipboard("fake");
    5454            }
     
    8383            }
    8484        } catch (UnsupportedFlavorException | IOException ex) {
    85             Main.error(ex);
     85            Logging.error(ex);
    8686        }
    8787        return null;
     
    109109                // Clipboard currently unavailable.
    110110                // On some platforms, the system clipboard is unavailable while it is accessed by another application.
    111                 Main.trace("Clipboard unavailable.", e);
     111                Logging.trace("Clipboard unavailable.", e);
    112112                try {
    113113                    Thread.sleep(1);
    114114                } catch (InterruptedException ex) {
    115                     Main.warn(ex, "InterruptedException in " + Utils.class.getSimpleName()
    116                             + " while getting clipboard content");
     115                    Logging.log(Logging.LEVEL_WARN, "InterruptedException in " + Utils.class.getSimpleName()
     116                            + " while getting clipboard content", ex);
    117117                    Thread.currentThread().interrupt();
    118118                }
    119119            } catch (NullPointerException e) { // NOPMD
    120120                // JDK-6322854: On Linux/X11, NPE can happen for unknown reasons, on all versions of Java
    121                 Main.error(e);
     121                Logging.error(e);
    122122            }
    123123        }
     
    145145                return Boolean.TRUE;
    146146            } catch (IllegalStateException ex) {
    147                 Main.error(ex);
     147                Logging.error(ex);
    148148                return Boolean.FALSE;
    149149            }
  • trunk/src/org/openstreetmap/josm/gui/datatransfer/OsmTransferHandler.java

    r12125 r12620  
    2121import org.openstreetmap.josm.gui.datatransfer.importers.TextTagPaster;
    2222import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     23import org.openstreetmap.josm.tools.Logging;
    2324
    2425/**
     
    4748                    }
    4849                } catch (UnsupportedFlavorException | IOException e) {
    49                     Main.warn(e);
     50                    Logging.warn(e);
    5051                }
    5152            }
     
    9697            }
    9798        } catch (IllegalStateException e) {
    98             Main.debug(e);
     99            Logging.debug(e);
    99100        } catch (NullPointerException e) { // NOPMD
    100101            // JDK-6322854: On Linux/X11, NPE can happen for unknown reasons, on all versions of Java
    101             Main.error(e);
     102            Logging.error(e);
    102103        }
    103104        return false;
  • trunk/src/org/openstreetmap/josm/gui/datatransfer/importers/TextTagPaster.java

    r12537 r12620  
    1111import javax.swing.TransferHandler.TransferSupport;
    1212
    13 import org.openstreetmap.josm.Main;
     13import org.openstreetmap.josm.tools.Logging;
    1414import org.openstreetmap.josm.tools.TextTagParser;
    1515
     
    3434            return super.supports(support) && containsValidTags(support);
    3535        } catch (UnsupportedFlavorException | IOException e) {
    36             Main.warn(e);
     36            Logging.warn(e);
    3737            return false;
    3838        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r12373 r12620  
    5858import org.openstreetmap.josm.io.OnlineResource;
    5959import org.openstreetmap.josm.tools.ImageProvider;
     60import org.openstreetmap.josm.tools.Logging;
    6061import org.openstreetmap.josm.tools.OpenBrowser;
    6162import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
     
    523524                        future.get();
    524525                    } catch (InterruptedException e1) {
    525                         Main.warn(e1, "InterruptedException in ChangesetDialog while downloading changeset header");
     526                        Logging.log(Logging.LEVEL_WARN, "InterruptedException in ChangesetDialog while downloading changeset header", e1);
    526527                        Thread.currentThread().interrupt();
    527528                    } catch (ExecutionException e2) {
    528                         Main.error(e2);
     529                        Logging.error(e2);
    529530                        BugReportExceptionHandler.handleException(e2.getCause());
    530531                        return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r12499 r12620  
    6868import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    6969import org.openstreetmap.josm.tools.ImageProvider;
     70import org.openstreetmap.josm.tools.Logging;
    7071import org.openstreetmap.josm.tools.Shortcut;
    7172
     
    318319    @Override
    319320    public void onConflictsRemoved(ConflictCollection conflicts) {
    320         Main.info("1 conflict has been resolved.");
     321        Logging.info("1 conflict has been resolved.");
    321322        refreshView();
    322323    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterTableModel.java

    r12400 r12620  
    1717import org.openstreetmap.josm.gui.autofilter.AutoFilterManager;
    1818import org.openstreetmap.josm.gui.widgets.OSDLabel;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    267268                return trc("filter", "F");
    268269            default:
    269                 Main.warn("Unknown filter mode: " + f.mode);
     270                Logging.warn("Unknown filter mode: " + f.mode);
    270271            }
    271272            break;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LatLonDialog.java

    r12301 r12620  
    3131import org.openstreetmap.josm.gui.widgets.JosmTextField;
    3232import org.openstreetmap.josm.tools.GBC;
     33import org.openstreetmap.josm.tools.Logging;
    3334import org.openstreetmap.josm.tools.Utils;
    3435import org.openstreetmap.josm.tools.WindowGeometry;
     
    249250            }
    250251        } catch (IllegalArgumentException e) {
    251             Main.trace(e);
     252            Logging.trace(e);
    252253            latLon = null;
    253254        }
     
    268269            en = parseEastNorth(tfEastNorth.getText());
    269270        } catch (IllegalArgumentException e) {
    270             Main.trace(e);
     271            Logging.trace(e);
    271272            en = null;
    272273        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/MapPaintDialog.java

    r12279 r12620  
    7979import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
    8080import org.openstreetmap.josm.tools.InputMapUtils;
     81import org.openstreetmap.josm.tools.Logging;
    8182import org.openstreetmap.josm.tools.Shortcut;
    8283import org.openstreetmap.josm.tools.Utils;
     
    490491                    }
    491492                } catch (IOException e) {
    492                     Main.warn(e);
     493                    Logging.warn(e);
    493494                    error = true;
    494495                }
     
    638639                }
    639640            } catch (IOException ex) {
    640                 Main.error(ex);
     641                Logging.error(ex);
    641642                txtSource.append("<ERROR: failed to read file!>");
    642643            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r11885 r12620  
    6969import org.openstreetmap.josm.tools.GBC;
    7070import org.openstreetmap.josm.tools.ImageProvider;
     71import org.openstreetmap.josm.tools.Logging;
    7172import org.openstreetmap.josm.tools.Shortcut;
    7273import org.openstreetmap.josm.tools.WindowGeometry;
     
    110111            } catch (IllegalArgumentException e) {
    111112                // Legacy settings
    112                 Main.trace(e);
     113                Logging.trace(e);
    113114                return Boolean.parseBoolean(s) ? ButtonHidingType.DYNAMIC : ButtonHidingType.ALWAYS_SHOWN;
    114115            }
     
    708709                new WindowGeometry(preferencePrefix+".geometry").applySafe(this);
    709710            } catch (WindowGeometryException e) {
    710                 Main.debug(e);
     711                Logging.debug(e);
    711712                ToggleDialog.this.setPreferredSize(ToggleDialog.this.getDefaultDetachedSize());
    712713                pack();
     
    932933                        buttonActions.add(action);
    933934                    } else {
    934                         Main.warn("Button " + button + " doesn't have action defined");
    935                         Main.error(new Exception());
     935                        Logging.warn("Button " + button + " doesn't have action defined");
     936                        Logging.error(new Exception());
    936937                    }
    937938                }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/UserListDialog.java

    r12279 r12620  
    4242import org.openstreetmap.josm.gui.util.GuiHelper;
    4343import org.openstreetmap.josm.tools.ImageProvider;
     44import org.openstreetmap.josm.tools.Logging;
    4445import org.openstreetmap.josm.tools.OpenBrowser;
    4546import org.openstreetmap.josm.tools.Shortcut;
     
    199200                return;
    200201            if (users.size() > 10) {
    201                 Main.warn(tr("Only launching info browsers for the first {0} of {1} selected users", 10, users.size()));
     202                Logging.warn(tr("Only launching info browsers for the first {0} of {1} selected users", 10, users.size()));
    202203            }
    203204            int num = Math.min(10, users.size());
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManager.java

    r12495 r12620  
    6565import org.openstreetmap.josm.tools.ImageProvider;
    6666import org.openstreetmap.josm.tools.InputMapUtils;
     67import org.openstreetmap.josm.tools.Logging;
    6768import org.openstreetmap.josm.tools.StreamUtils;
    6869import org.openstreetmap.josm.tools.WindowGeometry;
     
    404405                    }
    405406                } catch (IllegalStateException e) {
    406                     Main.error(e);
     407                    Logging.error(e);
    407408                    JOptionPane.showMessageDialog(parent, e.getMessage(), tr("Error"), JOptionPane.ERROR_MESSAGE);
    408409                }
     
    642643            } catch (IllegalStateException ex) {
    643644                alertAnonymousUser(parent);
    644                 Main.trace(ex);
     645                Logging.trace(ex);
    645646            }
    646647        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/BasicChangesetQueryPanel.java

    r11326 r12620  
    2525import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    2626import org.openstreetmap.josm.io.ChangesetQuery;
     27import org.openstreetmap.josm.tools.Logging;
    2728
    2829/**
     
    204205                q = BasicQuery.valueOf(BasicQuery.class, value);
    205206            } catch (IllegalArgumentException e) {
    206                 Main.warn(e, tr("Unexpected value for preference ''{0}'', got ''{1}''. Resetting to default query.",
    207                         "changeset-query.basic.query", value));
     207                Logging.log(Logging.LEVEL_WARN, tr("Unexpected value for preference ''{0}'', got ''{1}''. Resetting to default query.",
     208                        "changeset-query.basic.query", value), e);
    208209                q = BasicQuery.MOST_RECENT_CHANGESETS;
    209210            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/ChangesetQueryDialog.java

    r11326 r12620  
    2020import javax.swing.JTabbedPane;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2423import org.openstreetmap.josm.gui.help.ContextSensitiveHelpAction;
     
    2726import org.openstreetmap.josm.tools.ImageProvider;
    2827import org.openstreetmap.josm.tools.InputMapUtils;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.WindowGeometry;
    3030
     
    204204                setVisible(false);
    205205            } catch (IllegalStateException e) {
    206                 Main.error(e);
     206                Logging.error(e);
    207207                JOptionPane.showMessageDialog(ChangesetQueryDialog.this, e.getMessage(), tr("Error"), JOptionPane.ERROR_MESSAGE);
    208208            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/DateValidator.java

    r11326 r12620  
    1212import javax.swing.text.JTextComponent;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.gui.widgets.AbstractTextComponentValidator;
     15import org.openstreetmap.josm.tools.Logging;
    1616
    1717/**
     
    9696            } catch (DateTimeParseException e) {
    9797                // Try next format
    98                 Main.trace(e);
     98                Logging.trace(e);
    9999            }
    100100        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/TimeValidator.java

    r11326 r12620  
    1212import javax.swing.text.JTextComponent;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.gui.widgets.AbstractTextComponentValidator;
     15import org.openstreetmap.josm.tools.Logging;
    1616
    1717/**
     
    101101            } catch (DateTimeParseException e) {
    102102                // Try next format
    103                 Main.trace(e);
     103                Logging.trace(e);
    104104            }
    105105        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/UrlBasedQueryPanel.java

    r11326 r12620  
    2727import org.openstreetmap.josm.io.OsmApi;
    2828import org.openstreetmap.josm.tools.ImageProvider;
     29import org.openstreetmap.josm.tools.Logging;
    2930
    3031/**
     
    138139            return ChangesetQuery.buildFromUrlQuery(url.getQuery());
    139140        } catch (ChangesetQueryUrlException e) {
    140             Main.warn(e);
     141            Logging.warn(e);
    141142            return null;
    142143        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerListTransferHandler.java

    r11893 r12620  
    1515import javax.swing.TransferHandler;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.data.osm.DataSet;
    1918import org.openstreetmap.josm.gui.datatransfer.LayerTransferable;
     
    2120import org.openstreetmap.josm.gui.layer.Layer;
    2221import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     22import org.openstreetmap.josm.tools.Logging;
    2323
    2424/**
     
    124124            return true;
    125125        } catch (UnsupportedFlavorException e) {
    126             Main.warn("Flavor not supported", e);
     126            Logging.warn("Flavor not supported", e);
    127127            return false;
    128128        } catch (IOException e) {
    129             Main.warn("Error while pasting layer", e);
     129            Logging.warn("Error while pasting layer", e);
    130130            return false;
    131131        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r12523 r12620  
    105105import org.openstreetmap.josm.tools.InputMapUtils;
    106106import org.openstreetmap.josm.tools.LanguageInfo;
     107import org.openstreetmap.josm.tools.Logging;
    107108import org.openstreetmap.josm.tools.OpenBrowser;
    108109import org.openstreetmap.josm.tools.Shortcut;
     
    11721173                Main.worker.execute(() -> displayHelp(uris));
    11731174            } catch (URISyntaxException e1) {
    1174                 Main.error(e1);
     1175                Logging.error(e1);
    11751176            }
    11761177        }
     
    12021203                         */
    12031204                        if (osize > -1 && conn.getContentLength() != -1 && Math.abs(conn.getContentLength() - osize) > 200) {
    1204                             Main.info("{0} is a mediawiki redirect", u);
     1205                            Logging.info("{0} is a mediawiki redirect", u);
    12051206                            conn.disconnect();
    12061207                        } else {
     
    12131214                }
    12141215            } catch (URISyntaxException | IOException e1) {
    1215                 Main.error(e1);
     1216                Logging.error(e1);
    12161217            }
    12171218        }
     
    14151416                tagRowSorter.convertRowIndexToModel(tagTable.getSelectedRow());
    14161417            } catch (IndexOutOfBoundsException ignore) {
    1417                 Main.trace(ignore);
    1418                 Main.trace("Clearing tagTable selection");
     1418                Logging.trace(ignore);
     1419                Logging.trace("Clearing tagTable selection");
    14191420                tagTable.clearSelection();
    14201421            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/TagEditHelper.java

    r12619 r12620  
    8888import org.openstreetmap.josm.io.XmlWriter;
    8989import org.openstreetmap.josm.tools.GBC;
     90import org.openstreetmap.josm.tools.Logging;
    9091import org.openstreetmap.josm.tools.Shortcut;
    9192import org.openstreetmap.josm.tools.Utils;
     
    342343
    343344    private static void warnAboutParseError(SearchCompiler.ParseError parseError) {
    344         Main.warn(parseError);
     345        Logging.warn(parseError);
    345346        JOptionPane.showMessageDialog(
    346347                Main.parent,
     
    637638                   List<AutoCompletionListItem> valueList = autocomplete.getValues(getAutocompletionKeys(key));
    638639                   valueList.sort(comparator);
    639                    if (Main.isTraceEnabled()) {
    640                        Main.trace("Focus gained by {0}, e={1}", values, e);
    641                    }
     640                   Logging.trace("Focus gained by {0}, e={1}", values, e);
    642641                   values.setPossibleACItems(valueList);
    643642                   values.getEditor().selectAll();
     
    838837                    }
    839838                } catch (NumberFormatException ex) {
    840                     Main.warn(ex);
     839                    Logging.warn(ex);
    841840                }
    842841                JOptionPane.showMessageDialog(this, tr("Please enter integer number between 0 and {0}", MAX_LRU_TAGS_NUMBER));
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ChildRelationBrowser.java

    r11848 r12620  
    4646import org.openstreetmap.josm.tools.CheckParameterUtil;
    4747import org.openstreetmap.josm.tools.ImageProvider;
     48import org.openstreetmap.josm.tools.Logging;
    4849import org.openstreetmap.josm.tools.Utils;
    4950import org.xml.sax.SAXException;
     
    422423            } catch (OsmTransferException e) {
    423424                if (canceled) {
    424                     Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     425                    Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    425426                    return;
    426427                }
     
    471472            } catch (OsmTransferException e) {
    472473                if (canceled) {
    473                     Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     474                    Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    474475                    return;
    475476                }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationMemberTask.java

    r10611 r12620  
    2525import org.openstreetmap.josm.io.MultiFetchServerObjectReader;
    2626import org.openstreetmap.josm.io.OsmTransferException;
     27import org.openstreetmap.josm.tools.Logging;
    2728import org.xml.sax.SAXException;
    2829
     
    139140        } catch (OsmTransferException e) {
    140141            if (canceled) {
    141                 Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     142                Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    142143                return;
    143144            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationTask.java

    r10611 r12620  
    2121import org.openstreetmap.josm.io.OsmTransferException;
    2222import org.openstreetmap.josm.tools.CheckParameterUtil;
     23import org.openstreetmap.josm.tools.Logging;
    2324import org.xml.sax.SAXException;
    2425
     
    105106        } catch (OsmTransferException | InvocationTargetException | InterruptedException e) {
    106107            if (canceled) {
    107                 Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     108                Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    108109                return;
    109110            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r12080 r12620  
    9898import org.openstreetmap.josm.gui.tagging.presets.TaggingPresets;
    9999import org.openstreetmap.josm.tools.CheckParameterUtil;
     100import org.openstreetmap.josm.tools.Logging;
    100101import org.openstreetmap.josm.tools.Shortcut;
    101102import org.openstreetmap.josm.tools.Utils;
     
    841842        int code = shortcut.getKeyCode();
    842843        if (code != KeyEvent.VK_INSERT && (mods == 0 || mods == InputEvent.SHIFT_DOWN_MASK)) {
    843             Main.info(tr("Sorry, shortcut \"{0}\" can not be enabled in Relation editor dialog"), shortcut);
     844            Logging.info(tr("Sorry, shortcut \"{0}\" can not be enabled in Relation editor dialog"), shortcut);
    844845            return;
    845846        }
     
    947948            return modified ? new ChangeCommand(orig, relation) : null;
    948949        } catch (AddAbortException ign) {
    949             Main.trace(ign);
     950            Logging.trace(ign);
    950951            return null;
    951952        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTransferHandler.java

    r11881 r12620  
    1414import javax.swing.TransferHandler;
    1515
    16 import org.openstreetmap.josm.Main;
    1716import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1817import org.openstreetmap.josm.data.osm.PrimitiveData;
     
    2221import org.openstreetmap.josm.gui.datatransfer.RelationMemberTransferable;
    2322import org.openstreetmap.josm.gui.datatransfer.data.PrimitiveTransferData;
     23import org.openstreetmap.josm.tools.Logging;
    2424
    2525/**
     
    9191            }
    9292        } catch (IOException | UnsupportedFlavorException e) {
    93             Main.warn(e);
     93            Logging.warn(e);
    9494            return false;
    9595        }
     
    147147            final OsmPrimitive p = destination.getLayer().data.getPrimitiveById(data);
    148148            if (p == null) {
    149                 Main.warn(tr("Cannot add {0} since it is not part of dataset", data));
     149                Logging.warn(tr("Cannot add {0} since it is not part of dataset", data));
    150150                return null;
    151151            } else {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ParentRelationLoadingTask.java

    r11627 r12620  
    2323import org.openstreetmap.josm.io.OsmTransferException;
    2424import org.openstreetmap.josm.tools.CheckParameterUtil;
     25import org.openstreetmap.josm.tools.Logging;
    2526import org.xml.sax.SAXException;
    2627
     
    179180        } catch (OsmTransferException e) {
    180181            if (canceled) {
    181                 Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     182                Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    182183                return;
    183184            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationEditor.java

    r10212 r12620  
    1717import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1818import org.openstreetmap.josm.tools.CheckParameterUtil;
     19import org.openstreetmap.josm.tools.Logging;
    1920
    2021/**
     
    107108                }
    108109            } catch (ReflectiveOperationException ex) {
    109                 Main.warn(ex);
     110                Logging.warn(ex);
    110111            }
    111112        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationTree.java

    r10611 r12620  
    2626import org.openstreetmap.josm.io.OsmServerObjectReader;
    2727import org.openstreetmap.josm.io.OsmTransferException;
     28import org.openstreetmap.josm.tools.Logging;
    2829import org.xml.sax.SAXException;
    2930
     
    132133                return;
    133134            if (lastException != null) {
    134                 Main.error(lastException);
     135                Logging.error(lastException);
    135136                return;
    136137            }
     
    152153            } catch (OsmTransferException e) {
    153154                if (canceled) {
    154                     Main.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
     155                    Logging.warn(tr("Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    155156                    return;
    156157                }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AddSelectedAfterSelection.java

    r10420 r12620  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor.AddAbortException;
    109import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
     
    1211import org.openstreetmap.josm.gui.dialogs.relation.SelectionTableModel;
    1312import org.openstreetmap.josm.tools.ImageProvider;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    4343                    memberTableModel.getSelectionModel().getMaxSelectionIndex());
    4444        } catch (AddAbortException ex) {
    45             Main.trace(ex);
     45            Logging.trace(ex);
    4646        }
    4747    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AddSelectedAtEndAction.java

    r10420 r12620  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor.AddAbortException;
    109import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
     
    1211import org.openstreetmap.josm.gui.dialogs.relation.SelectionTableModel;
    1312import org.openstreetmap.josm.tools.ImageProvider;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    4242            memberTableModel.addMembersAtEnd(filterConfirmedPrimitives(selectionTableModel.getSelection()));
    4343        } catch (AddAbortException ex) {
    44             Main.trace(ex);
     44            Logging.trace(ex);
    4545        }
    4646    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AddSelectedAtStartAction.java

    r10420 r12620  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor.AddAbortException;
    109import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
     
    1211import org.openstreetmap.josm.gui.dialogs.relation.SelectionTableModel;
    1312import org.openstreetmap.josm.tools.ImageProvider;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    4242            memberTableModel.addMembersAtBeginning(filterConfirmedPrimitives(selectionTableModel.getSelection()));
    4343        } catch (AddAbortException ex) {
    44             Main.trace(ex);
     44            Logging.trace(ex);
    4545        }
    4646    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/AddSelectedBeforeSelection.java

    r10420 r12620  
    66import java.awt.event.ActionEvent;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor.AddAbortException;
    109import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
     
    1211import org.openstreetmap.josm.gui.dialogs.relation.SelectionTableModel;
    1312import org.openstreetmap.josm.tools.ImageProvider;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    4343                    memberTableModel.getSelectionModel().getMinSelectionIndex());
    4444        } catch (AddAbortException ex) {
    45             Main.trace(ex);
     45            Logging.trace(ex);
    4646        }
    4747    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/PasteMembersAction.java

    r11678 r12620  
    99import javax.swing.TransferHandler.TransferSupport;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
    1312import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
     
    1514import org.openstreetmap.josm.gui.dialogs.relation.MemberTransferHandler;
    1615import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     16import org.openstreetmap.josm.tools.Logging;
    1717
    1818/**
     
    3838            new MemberTransferHandler().importData(getSupport());
    3939        } catch (IllegalStateException ex) {
    40             Main.error(ex);
     40            Logging.error(ex);
    4141        }
    4242    }
     
    5252            setEnabled(new MemberTransferHandler().canImport(getSupport()));
    5353        } catch (IllegalStateException ex) {
    54             Main.error(ex);
     54            Logging.error(ex);
    5555        }
    5656    }
  • trunk/src/org/openstreetmap/josm/gui/download/BookmarkList.java

    r12606 r12620  
    4040import org.openstreetmap.josm.tools.ImageProvider;
    4141import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
     42import org.openstreetmap.josm.tools.Logging;
    4243
    4344/**
     
    255256                model.addElement(new HomeLocationBookmark());
    256257            } catch (IllegalStateException e) {
    257                 Main.info(e.getMessage());
    258                 Main.trace(e);
     258                Logging.info(e.getMessage());
     259                Logging.trace(e);
    259260            }
    260261        }
     
    267268                    bookmarks.add(new Bookmark(entry));
    268269                } catch (IllegalArgumentException e) {
    269                     Main.error(e, tr("Error reading bookmark entry: %s", e.getMessage()));
     270                    Logging.log(Logging.LEVEL_ERROR, tr("Error reading bookmark entry: %s", e.getMessage()), e);
    270271                }
    271272            }
  • trunk/src/org/openstreetmap/josm/gui/download/DownloadDialog.java

    r12575 r12620  
    4949import org.openstreetmap.josm.tools.ImageProvider;
    5050import org.openstreetmap.josm.tools.InputMapUtils;
     51import org.openstreetmap.josm.tools.Logging;
    5152import org.openstreetmap.josm.tools.OsmUrlToBounds;
    5253import org.openstreetmap.josm.tools.Utils;
     
    147148            tpDownloadAreaSelectors.setSelectedIndex(DOWNLOAD_TAB.get());
    148149        } catch (IndexOutOfBoundsException ex) {
    149             Main.trace(ex);
     150            Logging.trace(ex);
    150151            DOWNLOAD_TAB.put(0);
    151152        }
     
    434435                return new Bounds(value, ";");
    435436            } catch (IllegalArgumentException e) {
    436                 Main.warn(e);
     437                Logging.warn(e);
    437438            }
    438439        }
  • trunk/src/org/openstreetmap/josm/gui/download/OverpassQueryList.java

    r12609 r12620  
    5050import org.openstreetmap.josm.gui.widgets.SearchTextResultListPanel;
    5151import org.openstreetmap.josm.tools.GBC;
     52import org.openstreetmap.josm.tools.Logging;
    5253import org.openstreetmap.josm.tools.Utils;
    5354
     
    276277            } catch (IllegalArgumentException | DateTimeParseException e) {
    277278                // skip any corrupted item
    278                 Main.error(e);
     279                Logging.error(e);
    279280            }
    280281        }
  • trunk/src/org/openstreetmap/josm/gui/download/OverpassQueryWizardDialog.java

    r12609 r12620  
    2626import org.openstreetmap.josm.gui.widgets.HistoryComboBox;
    2727import org.openstreetmap.josm.tools.GBC;
     28import org.openstreetmap.josm.tools.Logging;
    2829import org.openstreetmap.josm.tools.OpenBrowser;
    2930import org.openstreetmap.josm.tools.OverpassTurboQueryWizard;
     
    140141            return Optional.of(query);
    141142        } catch (UncheckedParseException ex) {
    142             Main.error(ex);
     143            Logging.error(ex);
    143144            JOptionPane.showMessageDialog(
    144145                    parentDialog,
  • trunk/src/org/openstreetmap/josm/gui/download/PlaceSelection.java

    r11009 r12620  
    5757import org.openstreetmap.josm.tools.HttpClient;
    5858import org.openstreetmap.josm.tools.ImageProvider;
     59import org.openstreetmap.josm.tools.Logging;
    5960import org.openstreetmap.josm.tools.Utils;
    6061import org.xml.sax.SAXException;
     
    267268                if (!canceled) {
    268269                    // Nominatim sometimes returns garbage, see #5934, #10643
    269                     Main.warn(e, tr("Error occured with query ''{0}'': ''{1}''", urlString, e.getMessage()));
     270                    Logging.log(Logging.LEVEL_WARN, tr("Error occured with query ''{0}'': ''{1}''", urlString, e.getMessage()), e);
    270271                    GuiHelper.runInEDTAndWait(() -> HelpAwareOptionPane.showOptionDialog(
    271272                            Main.parent,
  • trunk/src/org/openstreetmap/josm/gui/help/HelpBrowser.java

    r12537 r12620  
    5252import org.openstreetmap.josm.tools.InputMapUtils;
    5353import org.openstreetmap.josm.tools.LanguageInfo.LocaleType;
     54import org.openstreetmap.josm.tools.Logging;
    5455import org.openstreetmap.josm.tools.OpenBrowser;
    5556import org.openstreetmap.josm.tools.WindowGeometry;
     
    142143            css = new String(cf.getByteContent(), StandardCharsets.ISO_8859_1);
    143144        } catch (IOException e) {
    144             Main.error(tr("Failed to read CSS file ''help-browser.css''. Exception is: {0}", e.toString()));
    145             Main.error(e);
     145            Logging.error(tr("Failed to read CSS file ''help-browser.css''. Exception is: {0}", e.toString()));
     146            Logging.error(e);
    146147            return ss;
    147148        }
     
    236237            help.getEditorKit().read(new StringReader(content), document, 0);
    237238        } catch (IOException | BadLocationException e) {
    238             Main.error(e);
     239            Logging.error(e);
    239240        }
    240241        help.setDocument(document);
     
    300301            content = reader.fetchHelpTopicContent(url, true);
    301302        } catch (MissingHelpContentException e) {
    302             Main.trace(e);
     303            Logging.trace(e);
    303304            url = getHelpTopicUrl(buildAbsoluteHelpTopic(relativeHelpTopic, LocaleType.BASELANGUAGE));
    304305            try {
    305306                content = reader.fetchHelpTopicContent(url, true);
    306307            } catch (MissingHelpContentException e1) {
    307                 Main.trace(e1);
     308                Logging.trace(e1);
    308309                url = getHelpTopicUrl(buildAbsoluteHelpTopic(relativeHelpTopic, LocaleType.ENGLISH));
    309310                try {
    310311                    content = reader.fetchHelpTopicContent(url, true);
    311312                } catch (MissingHelpContentException e2) {
    312                     Main.debug(e2);
     313                    Logging.debug(e2);
    313314                    this.url = url;
    314315                    handleMissingHelpContent(relativeHelpTopic);
    315316                    return;
    316317                } catch (HelpContentReaderException e2) {
    317                     Main.error(e2);
     318                    Logging.error(e2);
    318319                    handleHelpContentReaderException(relativeHelpTopic, e2);
    319320                    return;
    320321                }
    321322            } catch (HelpContentReaderException e1) {
    322                 Main.error(e1);
     323                Logging.error(e1);
    323324                handleHelpContentReaderException(relativeHelpTopic, e1);
    324325                return;
    325326            }
    326327        } catch (HelpContentReaderException e) {
    327             Main.error(e);
     328            Logging.error(e);
    328329            handleHelpContentReaderException(relativeHelpTopic, e);
    329330            return;
     
    346347            content = reader.fetchHelpTopicContent(url, true);
    347348        } catch (MissingHelpContentException e) {
    348             Main.debug(e);
     349            Logging.debug(e);
    349350            this.url = url;
    350351            handleMissingHelpContent(absoluteHelpTopic);
    351352            return;
    352353        } catch (HelpContentReaderException e) {
    353             Main.error(e);
     354            Logging.error(e);
    354355            handleHelpContentReaderException(absoluteHelpTopic, e);
    355356            return;
     
    377378                this.url = url;
    378379            } catch (HelpContentReaderException e) {
    379                 Main.warn(e);
     380                Logging.warn(e);
    380381                HelpAwareOptionPane.showOptionDialog(
    381382                        Main.parent,
     
    587588                    }
    588589                } catch (BadLocationException e) {
    589                     Main.warn(tr("Bad location in HTML document. Exception was: {0}", e.toString()));
    590                     Main.error(e);
     590                    Logging.warn(tr("Bad location in HTML document. Exception was: {0}", e.toString()));
     591                    Logging.error(e);
    591592                }
    592593            }
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java

    r11647 r12620  
    4242import org.openstreetmap.josm.gui.util.ChangeNotifier;
    4343import org.openstreetmap.josm.tools.CheckParameterUtil;
     44import org.openstreetmap.josm.tools.Logging;
    4445
    4546/**
     
    138139            HistoryOsmPrimitive.forOsmPrimitive(primitive);
    139140        } catch (IllegalArgumentException ign) {
    140             Main.trace(ign);
     141            Logging.trace(ign);
    141142            return false;
    142143        }
  • trunk/src/org/openstreetmap/josm/gui/history/VersionTableModel.java

    r12511 r12620  
    66import javax.swing.table.AbstractTableModel;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.data.osm.Changeset;
    109import org.openstreetmap.josm.data.osm.User;
    1110import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
     11import org.openstreetmap.josm.tools.Logging;
    1212import org.openstreetmap.josm.tools.date.DateUtils;
    1313
     
    9494            }
    9595        } catch (IllegalArgumentException e) {
    96             Main.error(e);
     96            Logging.error(e);
    9797        }
    9898        fireTableDataChanged();
  • trunk/src/org/openstreetmap/josm/gui/io/AbstractUploadTask.java

    r12452 r12620  
    3434import org.openstreetmap.josm.tools.ExceptionUtil;
    3535import org.openstreetmap.josm.tools.ImageProvider;
     36import org.openstreetmap.josm.tools.Logging;
    3637import org.openstreetmap.josm.tools.Pair;
    3738import org.openstreetmap.josm.tools.date.DateUtils;
     
    298299            }
    299300        }
    300         Main.warn(tr("Error header \"{0}\" did not match with an expected pattern", errorHeader));
     301        Logging.warn(tr("Error header \"{0}\" did not match with an expected pattern", errorHeader));
    301302        handleUploadConflictForUnknownConflict();
    302303    }
     
    313314            handleUploadPreconditionFailedConflict(e, conflict);
    314315        } else {
    315             Main.warn(tr("Error header \"{0}\" did not match with an expected pattern", e.getErrorHeader()));
     316            Logging.warn(tr("Error header \"{0}\" did not match with an expected pattern", e.getErrorHeader()));
    316317            ExceptionDialogUtil.explainPreconditionFailed(e);
    317318        }
  • trunk/src/org/openstreetmap/josm/gui/io/CredentialDialog.java

    r12452 r12620  
    3939import org.openstreetmap.josm.tools.ImageProvider;
    4040import org.openstreetmap.josm.tools.InputMapUtils;
     41import org.openstreetmap.josm.tools.Logging;
    4142import org.openstreetmap.josm.tools.WindowGeometry;
    4243
     
    113114            setAlwaysOnTop(true);
    114115        } catch (SecurityException e) {
    115             Main.warn(e, tr("Failed to put Credential Dialog always on top. Caught security exception."));
     116            Logging.log(Logging.LEVEL_WARN, tr("Failed to put Credential Dialog always on top. Caught security exception."), e);
    116117        }
    117118        build();
  • trunk/src/org/openstreetmap/josm/gui/io/DownloadFileTask.java

    r11100 r12620  
    1919import java.util.zip.ZipFile;
    2020
    21 import org.openstreetmap.josm.Main;
    2221import org.openstreetmap.josm.gui.PleaseWaitDialog;
    2322import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2423import org.openstreetmap.josm.tools.HttpClient;
     24import org.openstreetmap.josm.tools.Logging;
    2525import org.openstreetmap.josm.tools.Utils;
    2626import org.xml.sax.SAXException;
     
    133133            }
    134134            if (!canceled) {
    135                 Main.info(tr("Download finished"));
     135                Logging.info(tr("Download finished"));
    136136                if (unpack) {
    137                     Main.info(tr("Unpacking {0} into {1}", file.getAbsolutePath(), file.getParent()));
     137                    Logging.info(tr("Unpacking {0} into {1}", file.getAbsolutePath(), file.getParent()));
    138138                    unzipFileRecursively(file, file.getParent());
    139139                    Utils.deleteFile(file);
     
    143143            String msg = tr("Cannot download file ''{0}''. Its download link ''{1}'' is not a valid URL. Skipping download.",
    144144                    file.getName(), address);
    145             Main.warn(msg);
     145            Logging.warn(msg);
    146146            throw new DownloadException(msg, e);
    147147        } catch (IOException e) {
     
    160160            download();
    161161        } catch (DownloadException e) {
    162             Main.error(e);
     162            Logging.error(e);
    163163        }
    164164    }
  • trunk/src/org/openstreetmap/josm/gui/io/DownloadOpenChangesetsTask.java

    r12012 r12620  
    2525import org.openstreetmap.josm.io.OsmServerUserInfoReader;
    2626import org.openstreetmap.josm.io.OsmTransferException;
     27import org.openstreetmap.josm.tools.Logging;
    2728import org.xml.sax.SAXException;
    2829
     
    6566                    + "You have either chosen to work anonymously or you are not entitled<br>"
    6667                    + "to know the identity of the user on whose behalf you are working.");
    67             Main.warn(msg);
     68            Logging.warn(msg);
    6869            if (!GraphicsEnvironment.isHeadless()) {
    6970                JOptionPane.showMessageDialog(GuiHelper.getFrameForComponent(parent),
     
    113114                im.setPartiallyIdentified(im.getUserName());
    114115            }
    115             Main.warn(e, tr("Failed to retrieve user infos for the current JOSM user. Exception was: {0}", e.toString()));
     116            Logging.log(Logging.LEVEL_WARN,
     117                    tr("Failed to retrieve user infos for the current JOSM user. Exception was: {0}", e.toString()), e);
    116118        }
    117119    }
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayerTask.java

    r11746 r12620  
    66import java.util.Optional;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.actions.SaveAction;
    109import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
     
    1211import org.openstreetmap.josm.tools.CheckParameterUtil;
    1312import org.openstreetmap.josm.tools.JosmRuntimeException;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    5757            }
    5858        } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    59             Main.error(e);
     59            Logging.error(e);
    6060            setLastException(e);
    6161        }
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

    r12452 r12620  
    5555import org.openstreetmap.josm.tools.ImageProvider;
    5656import org.openstreetmap.josm.tools.InputMapUtils;
     57import org.openstreetmap.josm.tools.Logging;
    5758import org.openstreetmap.josm.tools.UserCancelException;
    5859import org.openstreetmap.josm.tools.Utils;
     
    446447                closeDialog();
    447448            } catch (UserCancelException ignore) {
    448                 Main.trace(ignore);
     449                Logging.trace(ignore);
    449450            }
    450451        }
     
    575576                    currentFuture.get();
    576577                } catch (CancellationException e) {
    577                     Main.trace(e);
     578                    Logging.trace(e);
    578579                    model.setUploadState(layer, UploadOrSaveState.CANCELED);
    579580                } catch (InterruptedException | ExecutionException e) {
    580                     Main.error(e);
     581                    Logging.error(e);
    581582                    model.setUploadState(layer, UploadOrSaveState.FAILED);
    582583                    ExceptionDialogUtil.explainException(e);
     
    585586                    model.setUploadState(layer, UploadOrSaveState.CANCELED);
    586587                } else if (currentTask.isFailed()) {
    587                     Main.error(currentTask.getLastException());
     588                    Logging.error(currentTask.getLastException());
    588589                    ExceptionDialogUtil.explainException(currentTask.getLastException());
    589590                    model.setUploadState(layer, UploadOrSaveState.FAILED);
     
    616617                    currentFuture.get();
    617618                } catch (CancellationException e) {
    618                     Main.trace(e);
     619                    Logging.trace(e);
    619620                    model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    620621                } catch (InterruptedException | ExecutionException e) {
    621                     Main.error(e);
     622                    Logging.error(e);
    622623                    model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.FAILED);
    623624                    ExceptionDialogUtil.explainException(e);
     
    627628                } else if (currentTask.isFailed()) {
    628629                    if (currentTask.getLastException() != null) {
    629                         Main.error(currentTask.getLastException());
     630                        Logging.error(currentTask.getLastException());
    630631                        ExceptionDialogUtil.explainException(currentTask.getLastException());
    631632                    }
     
    642643            if (numProblems == 0)
    643644                return;
    644             Main.warn(numProblems + " problems occured during upload/save");
     645            Logging.warn(numProblems + " problems occured during upload/save");
    645646            String msg = trn(
    646647                    "<html>An upload and/or save operation of one layer with modifications<br>"
  • trunk/src/org/openstreetmap/josm/gui/io/UploadLayerTask.java

    r11604 r12620  
    99import java.util.Set;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.actions.upload.CyclicUploadDependencyException;
    1312import org.openstreetmap.josm.data.APIDataSet;
     
    2524import org.openstreetmap.josm.io.OsmTransferException;
    2625import org.openstreetmap.josm.tools.CheckParameterUtil;
     26import org.openstreetmap.josm.tools.Logging;
    2727
    2828/**
     
    9191        if (p.isDeleted()) {
    9292            // we tried to delete an already deleted primitive.
    93             Main.warn(tr("Object ''{0}'' is already deleted on the server. Skipping this object and retrying to upload.",
     93            Logging.warn(tr("Object ''{0}'' is already deleted on the server. Skipping this object and retrying to upload.",
    9494                    p.getDisplayName(DefaultNameFormatter.getInstance())));
    9595            processedPrimitives.addAll(writer.getProcessedPrimitives());
     
    134134        } catch (OsmTransferException sxe) {
    135135            if (isCanceled()) {
    136                 Main.info("Ignoring exception caught because upload is canceled. Exception is: " + sxe);
     136                Logging.info("Ignoring exception caught because upload is canceled. Exception is: " + sxe);
    137137                return;
    138138            }
  • trunk/src/org/openstreetmap/josm/gui/io/UploadPrimitivesTask.java

    r11686 r12620  
    3838import org.openstreetmap.josm.io.OsmTransferException;
    3939import org.openstreetmap.josm.tools.ImageProvider;
     40import org.openstreetmap.josm.tools.Logging;
    4041
    4142/**
     
    200201            }
    201202            monitor.appendLogMessage(msg);
    202             Main.warn(msg);
     203            Logging.warn(msg);
    203204            processedPrimitives.addAll(writer.getProcessedPrimitives());
    204205            processedPrimitives.add(p);
     
    224225            SwingUtilities.invokeAndWait(r);
    225226        } catch (InterruptedException e) {
    226             Main.trace(e);
     227            Logging.trace(e);
    227228            lastException = e;
    228229            Thread.currentThread().interrupt();
    229230        } catch (InvocationTargetException e) {
    230             Main.trace(e);
     231            Logging.trace(e);
    231232            lastException = new OsmTransferException(e.getCause());
    232233        }
     
    249250                    break;
    250251                } catch (OsmTransferCanceledException e) {
    251                     Main.error(e);
     252                    Logging.error(e);
    252253                    uploadCanceled = true;
    253254                    break uploadloop;
     
    292293        } catch (OsmTransferException e) {
    293294            if (uploadCanceled) {
    294                 Main.info(tr("Ignoring caught exception because upload is canceled. Exception is: {0}", e.toString()));
     295                Logging.info(tr("Ignoring caught exception because upload is canceled. Exception is: {0}", e.toString()));
    295296            } else {
    296297                lastException = e;
  • trunk/src/org/openstreetmap/josm/gui/io/UploadStrategy.java

    r12370 r12620  
    77
    88import org.openstreetmap.josm.Main;
     9import org.openstreetmap.josm.tools.Logging;
    910
    1011/**
     
    9697        UploadStrategy strategy = fromPreference(v);
    9798        if (strategy == null) {
    98             Main.warn(tr("Unexpected value for key ''{0}'' in preferences, got ''{1}''", "osm-server.upload-strategy", v));
     99            Logging.warn(tr("Unexpected value for key ''{0}'' in preferences, got ''{1}''", "osm-server.upload-strategy", v));
    99100            return DEFAULT_UPLOAD_STRATEGY;
    100101        }
  • trunk/src/org/openstreetmap/josm/gui/io/UploadStrategySelectionPanel.java

    r12370 r12620  
    3636import org.openstreetmap.josm.io.Capabilities;
    3737import org.openstreetmap.josm.io.OsmApi;
     38import org.openstreetmap.josm.tools.Logging;
    3839
    3940/**
     
    336337        } catch (NumberFormatException e) {
    337338            // don't save invalid value to preferences
    338             Main.trace(e);
     339            Logging.trace(e);
    339340        }
    340341    }
  • trunk/src/org/openstreetmap/josm/gui/layer/AbstractCachedTileSourceLayer.java

    r11188 r12620  
    1010import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
    1111import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
    1413import org.openstreetmap.josm.data.cache.JCSCacheManager;
     
    1716import org.openstreetmap.josm.data.imagery.TileLoaderFactory;
    1817import org.openstreetmap.josm.data.preferences.IntegerProperty;
     18import org.openstreetmap.josm.tools.Logging;
    1919
    2020/**
     
    9191            return cache;
    9292        } catch (IOException e) {
    93             Main.warn(e);
     93            Logging.warn(e);
    9494            return null;
    9595        }
     
    131131                        CachedTileLoaderFactory.PROP_TILECACHE_DIR.get());
    132132            } catch (IOException e) {
    133                 Main.warn(e);
     133                Logging.warn(e);
    134134                return null;
    135135            }
  • trunk/src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

    r12603 r12620  
    115115import org.openstreetmap.josm.io.WMSLayerImporter;
    116116import org.openstreetmap.josm.tools.GBC;
     117import org.openstreetmap.josm.tools.Logging;
    117118import org.openstreetmap.josm.tools.MemoryManager;
    118119import org.openstreetmap.josm.tools.MemoryManager.MemoryHandle;
     
    275276        } catch (MalformedURLException e) {
    276277            // ignore, assume that this is not a file
    277             if (Main.isDebugEnabled()) {
    278                 Main.debug(e.getMessage());
    279             }
     278            Logging.log(Logging.LEVEL_DEBUG, e);
    280279        }
    281280
     
    294293        tile.setLoaded(success);
    295294        invalidateLater();
    296         if (Main.isDebugEnabled()) {
    297             Main.debug("tileLoadingFinished() tile: " + tile + " success: " + success);
    298         }
     295        Logging.debug("tileLoadingFinished() tile: {0} success: {1}", tile, success);
    299296    }
    300297
     
    437434                } catch (IOException e) {
    438435                    // silence exceptions
    439                     Main.trace(e);
     436                    Logging.trace(e);
    440437                }
    441438
     
    595592                Math.pow(2d, ZOOM_OFFSET.get()) * visibileTiles // use offset to decide, how many tiles are visible
    596593                * 4);
    597         Main.info("AbstractTileSourceLayer: estimated visible tiles: {0}, estimated cache size: {1}", visibileTiles, ret);
     594        Logging.info("AbstractTileSourceLayer: estimated visible tiles: {0}, estimated cache size: {1}", visibileTiles, ret);
    598595        return ret;
    599596    }
     
    702699
    703700    private void zoomChanged(boolean invalidate) {
    704         if (Main.isDebugEnabled()) {
    705             Main.debug("zoomChanged(): " + currentZoomLevel);
    706         }
     701        Logging.debug("zoomChanged(): {0}", currentZoomLevel);
    707702        if (tileLoader instanceof TMSCachedTileLoader) {
    708703            ((TMSCachedTileLoader) tileLoader).cancelOutstandingTasks();
     
    733728    public boolean zoomIncreaseAllowed() {
    734729        boolean zia = currentZoomLevel < this.getMaxZoomLvl();
    735         if (Main.isDebugEnabled()) {
    736             Main.debug("zoomIncreaseAllowed(): " + zia + ' ' + currentZoomLevel + " vs. " + this.getMaxZoomLvl());
    737         }
     730        Logging.debug("zoomIncreaseAllowed(): {0} {1} vs. {2}", zia, currentZoomLevel, this.getMaxZoomLvl());
    738731        return zia;
    739732    }
     
    747740        if (zoomIncreaseAllowed()) {
    748741            currentZoomLevel++;
    749             if (Main.isDebugEnabled()) {
    750                 Main.debug("increasing zoom level to: " + currentZoomLevel);
    751             }
     742            Logging.debug("increasing zoom level to: {0}", currentZoomLevel);
    752743            zoomChanged();
    753744        } else {
    754             Main.warn("Current zoom level ("+currentZoomLevel+") could not be increased. "+
     745            Logging.warn("Current zoom level ("+currentZoomLevel+") could not be increased. "+
    755746                    "Max.zZoom Level "+this.getMaxZoomLvl()+" reached.");
    756747            return false;
     
    793784    public boolean zoomDecreaseAllowed() {
    794785        boolean zda = currentZoomLevel > this.getMinZoomLvl();
    795         if (Main.isDebugEnabled()) {
    796             Main.debug("zoomDecreaseAllowed(): " + zda + ' ' + currentZoomLevel + " vs. " + this.getMinZoomLvl());
    797         }
     786        Logging.debug("zoomDecreaseAllowed(): {0} {1} vs. {2}", zda, currentZoomLevel, this.getMinZoomLvl());
    798787        return zda;
    799788    }
     
    806795    public boolean decreaseZoomLevel() {
    807796        if (zoomDecreaseAllowed()) {
    808             if (Main.isDebugEnabled()) {
    809                 Main.debug("decreasing zoom level to: " + currentZoomLevel);
    810             }
     797            Logging.debug("decreasing zoom level to: {0}", currentZoomLevel);
    811798            currentZoomLevel--;
    812799            zoomChanged();
     
    879866        // if there is more than 18 tiles on screen in any direction, do not load all tiles!
    880867        if (ts.tooLarge()) {
    881             Main.warn("Not downloading all tiles because there is more than 18 tiles on an axis!");
     868            Logging.warn("Not downloading all tiles because there is more than 18 tiles on an axis!");
    882869            return;
    883870        }
     
    900887    public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
    901888        boolean done = (infoflags & (ERROR | FRAMEBITS | ALLBITS)) != 0;
    902         if (Main.isDebugEnabled()) {
    903             Main.debug("imageUpdate() done: " + done + " calling repaint");
    904         }
     889        Logging.debug("imageUpdate() done: {0} calling repaint", done);
    905890
    906891        if (done) {
     
    11361121        }
    11371122
    1138         if (Main.isDebugEnabled()) {
     1123        if (Logging.isDebugEnabled()) {
    11391124            // draw tile outline in semi-transparent red
    11401125            g.setColor(new Color(255, 0, 0, 50));
     
    14951480            missedTiles = newlyMissedTiles;
    14961481        }
    1497         if (Main.isDebugEnabled() && !missedTiles.isEmpty()) {
    1498             Main.debug("still missed "+missedTiles.size()+" in the end");
     1482        if (Logging.isDebugEnabled() && !missedTiles.isEmpty()) {
     1483            Logging.debug("still missed {0} in the end", missedTiles.size());
    14991484        }
    15001485        g.setColor(Color.red);
     
    15231508            myDrawString(g, tr("No tiles at this zoom level"), 120, 120);
    15241509        }
    1525         if (Main.isDebugEnabled()) {
     1510        if (Logging.isDebugEnabled()) {
    15261511            myDrawString(g, tr("Current zoom: {0}", currentZoomLevel), 50, 140);
    15271512            myDrawString(g, tr("Display zoom: {0}", displayZoomLevel), 50, 155);
     
    15471532     */
    15481533    private Tile getTileForPixelpos(int px, int py) {
    1549         if (Main.isDebugEnabled()) {
    1550             Main.debug("getTileForPixelpos("+px+", "+py+')');
    1551         }
     1534        Logging.debug("getTileForPixelpos({0}, {1})", px, py);
    15521535        TileXY xy = coordinateConverter.getTileforPixel(px, py, currentZoomLevel);
    15531536        return getTile(xy.getXIndex(), xy.getYIndex(), currentZoomLevel);
     
    17291712                this.progressMonitor.setCustomText(tr("Downloaded {0}/{1} tiles", processed, totalCount));
    17301713            } else {
    1731                 Main.warn("Tile loading failure: " + tile + " - " + tile.getErrorMessage());
     1714                Logging.warn("Tile loading failure: " + tile + " - " + tile.getErrorMessage());
    17321715            }
    17331716        }
     
    18251808                        memory = manager.allocateMemory("tile source layer", getEstimatedCacheSize(), Object::new);
    18261809                    } catch (NotEnoughMemoryException e) {
    1827                         Main.warn("Could not allocate tile source memory", e);
     1810                        Logging.warn("Could not allocate tile source memory", e);
    18281811                    }
    18291812                }
  • trunk/src/org/openstreetmap/josm/gui/layer/NoteLayer.java

    r12343 r12620  
    4444import org.openstreetmap.josm.tools.ColorHelper;
    4545import org.openstreetmap.josm.tools.ImageProvider;
     46import org.openstreetmap.josm.tools.Logging;
    4647import org.openstreetmap.josm.tools.date.DateUtils;
    4748
     
    183184                        // See #11123 - https://bugs.openjdk.java.net/browse/JDK-6719550
    184185                        // Ignore the exception, as Netbeans does: http://hg.netbeans.org/main-silver/rev/c96f4d5fbd20
    185                         Main.error(e, false);
     186                        Logging.log(Logging.LEVEL_ERROR, e);
    186187                    }
    187188                }
  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r12291 r12620  
    108108import org.openstreetmap.josm.tools.ImageProvider;
    109109import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
     110import org.openstreetmap.josm.tools.Logging;
    110111import org.openstreetmap.josm.tools.date.DateUtils;
    111112
     
    535536            visitor.merge(progressMonitor);
    536537        } catch (DataIntegrityProblemException e) {
    537             Main.error(e);
     538            Logging.error(e);
    538539            JOptionPane.showMessageDialog(
    539540                    Main.parent,
     
    816817                    }
    817818                } catch (NumberFormatException e) {
    818                     Main.trace(e);
     819                    Logging.trace(e);
    819820                }
    820821            }
     
    836837                    }
    837838                } catch (NumberFormatException e) {
    838                     Main.trace(e);
     839                    Logging.trace(e);
    839840                }
    840841            }
  • trunk/src/org/openstreetmap/josm/gui/layer/TMSLayer.java

    r11860 r12620  
    1313import org.openstreetmap.gui.jmapviewer.tilesources.TMSTileSource;
    1414import org.openstreetmap.gui.jmapviewer.tilesources.TemplatedTMSTileSource;
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
    1716import org.openstreetmap.josm.data.imagery.CachedAttributionBingAerialTileSource;
     
    2120import org.openstreetmap.josm.data.preferences.BooleanProperty;
    2221import org.openstreetmap.josm.data.preferences.IntegerProperty;
     22import org.openstreetmap.josm.tools.Logging;
    2323
    2424/**
     
    7171    protected TMSTileSource getTileSource() {
    7272        return getTileSourceStatic(info, () -> {
    73             Main.debug("Attribution loaded, running loadAllErrorTiles");
     73            Logging.debug("Attribution loaded, running loadAllErrorTiles");
    7474            this.loadAllErrorTiles(false);
    7575        });
  • trunk/src/org/openstreetmap/josm/gui/layer/WMSLayer.java

    r11956 r12620  
    3030import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
    3131import org.openstreetmap.josm.tools.CheckParameterUtil;
     32import org.openstreetmap.josm.tools.Logging;
    3233import org.openstreetmap.josm.tools.Utils;
    3334
     
    132133                Projection proj = Projections.getProjectionByCode(code);
    133134                if (proj != null) {
    134                     Main.info(tr("Reprojecting layer {0} from {1} to {2}. For best image quality and performance,"
     135                    Logging.info(tr("Reprojecting layer {0} from {1} to {2}. For best image quality and performance,"
    135136                            + " switch to one of the supported projections: {3}",
    136137                            getName(), proj.toCode(), Main.getProjection().toCode(), Utils.join(", ", getNativeProjections())));
     
    138139                }
    139140            }
    140             Main.warn(tr("Unable to find supported projection for layer {0}. Using {1}.", getName(), requested.toCode()));
     141            Logging.warn(tr("Unable to find supported projection for layer {0}. Using {1}.", getName(), requested.toCode()));
    141142            return requested;
    142143        }
  • trunk/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java

    r11950 r12620  
    1515import org.openstreetmap.josm.data.projection.Projection;
    1616import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
     17import org.openstreetmap.josm.tools.Logging;
    1718import org.openstreetmap.josm.tools.Utils;
    1819
     
    6364            return null;
    6465        } catch (IOException e) {
    65             Main.warn(e);
     66            Logging.warn(e);
    6667            throw new IllegalArgumentException(e);
    6768        }
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java

    r12279 r12620  
    8282import org.openstreetmap.josm.tools.ImageProvider;
    8383import org.openstreetmap.josm.tools.JosmRuntimeException;
     84import org.openstreetmap.josm.tools.Logging;
    8485import org.openstreetmap.josm.tools.Pair;
    8586import org.openstreetmap.josm.tools.Utils;
     
    291292
    292293                } catch (SAXException ex) {
    293                     Main.error(ex);
     294                    Logging.error(ex);
    294295                    JOptionPane.showMessageDialog(
    295296                            Main.parent,
     
    300301                    return;
    301302                } catch (IOException ex) {
    302                     Main.error(ex);
     303                    Logging.error(ex);
    303304                    JOptionPane.showMessageDialog(
    304305                            Main.parent,
     
    934935                sldSeconds.setValue((int) (deciSeconds % 60));
    935936            } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException e) {
    936                 Main.warn(e);
     937                Logging.warn(e);
    937938                JOptionPane.showMessageDialog(Main.parent,
    938939                        tr("An error occurred while trying to match the photos to the GPX track."
     
    10141015                delta = r.b;
    10151016            } catch (IndexOutOfBoundsException ex) {
    1016                 Main.debug(ex);
     1017                Logging.debug(ex);
    10171018                JOptionPane.showMessageDialog(Main.parent,
    10181019                        tr("The selected photos do not contain time information."),
     
    10201021                return;
    10211022            } catch (NoGpxTimestamps ex) {
    1022                 Main.debug(ex);
     1023                Logging.debug(ex);
    10231024                JOptionPane.showMessageDialog(Main.parent,
    10241025                        tr("The selected GPX track does not contain timestamps. Please select another one."),
     
    11331134                return Double.valueOf(value);
    11341135            } catch (NumberFormatException e) {
    1135                 Main.warn(e);
     1136                Logging.warn(e);
    11361137            }
    11371138        }
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java

    r12340 r12620  
    6868import org.openstreetmap.josm.io.JpgImporter;
    6969import org.openstreetmap.josm.tools.ImageProvider;
     70import org.openstreetmap.josm.tools.Logging;
    7071import org.openstreetmap.josm.tools.Utils;
    7172
     
    195196                addRecursiveFiles(files, selection);
    196197            } catch (IllegalStateException e) {
    197                 Main.debug(e);
     198                Logging.debug(e);
    198199                rememberError(e.getMessage());
    199200            }
     
    241242                        canonical = f.getCanonicalPath();
    242243                    } catch (IOException e) {
    243                         Main.error(e);
     244                        Logging.error(e);
    244245                        rememberError(tr("Unable to get canonical path for directory {0}\n",
    245246                                f.getAbsolutePath()));
     
    735736
    736737                if (Utils.deleteFile(toDelete.getFile())) {
    737                     Main.info("File "+toDelete.getFile()+" deleted. ");
     738                    Logging.info("File "+toDelete.getFile()+" deleted. ");
    738739                } else {
    739740                    JOptionPane.showMessageDialog(
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java

    r12460 r12620  
    2828import org.openstreetmap.josm.Main;
    2929import org.openstreetmap.josm.tools.ExifReader;
     30import org.openstreetmap.josm.tools.Logging;
    3031
    3132/**
     
    8687                    Thread.sleep(5);
    8788                } catch (InterruptedException e) {
    88                     Main.warn("InterruptedException in "+getClass().getSimpleName()+" while loading image "+file.getPath());
     89                    Logging.warn("InterruptedException in "+getClass().getSimpleName()+" while loading image "+file.getPath());
    8990                    Thread.currentThread().interrupt();
    9091                }
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageEntry.java

    r11746 r12620  
    88import java.util.Date;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.coor.CachedLatLon;
    1211import org.openstreetmap.josm.data.coor.LatLon;
    1312import org.openstreetmap.josm.tools.ExifReader;
    1413import org.openstreetmap.josm.tools.JosmRuntimeException;
     14import org.openstreetmap.josm.tools.Logging;
    1515
    1616import com.drew.imaging.jpeg.JpegMetadataReader;
     
    440440            metadata = JpegMetadataReader.readMetadata(file);
    441441        } catch (CompoundException | IOException ex) {
    442             Main.error(ex);
     442            Logging.error(ex);
    443443            setExifTime(null);
    444444            setExifCoor(null);
     
    452452            setExifTime(ExifReader.readTime(metadata));
    453453        } catch (JosmRuntimeException | IllegalArgumentException | IllegalStateException ex) {
    454             Main.warn(ex);
     454            Logging.warn(ex);
    455455            setExifTime(null);
    456456        }
     
    465465            }
    466466        } catch (MetadataException ex) {
    467             Main.debug(ex);
     467            Logging.debug(ex);
    468468        }
    469469
     
    489489            setPos(getExifCoor());
    490490        } catch (MetadataException | IndexOutOfBoundsException ex) { // (other exceptions, e.g. #5271)
    491             Main.error("Error reading EXIF from file: " + ex);
     491            Logging.error("Error reading EXIF from file: " + ex);
    492492            setExifCoor(null);
    493493            setPos(null);
     
    500500            }
    501501        } catch (IndexOutOfBoundsException ex) { // (other exceptions, e.g. #5271)
    502             Main.debug(ex);
     502            Logging.debug(ex);
    503503        }
    504504
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ThumbsLoader.java

    r12460 r12620  
    2222import org.openstreetmap.josm.data.cache.JCSCacheManager;
    2323import org.openstreetmap.josm.tools.ExifReader;
     24import org.openstreetmap.josm.tools.Logging;
    2425
    2526/**
    2627 * Loads thumbnail previews for a list of images from a {@link GeoImageLayer}.
    27  * 
     28 *
    2829 * Thumbnails are loaded in the background and cached on disk for the next session.
    2930 */
     
    6970                        Main.pref.getCacheDirectory().getPath() + File.separator + "geoimage-thumbnails");
    7071            } catch (IOException e) {
    71                 Main.warn("Failed to initialize cache for geoimage-thumbnails");
    72                 Main.warn(e);
     72                Logging.warn("Failed to initialize cache for geoimage-thumbnails");
     73                Logging.warn(e);
    7374            }
    7475        }
     
    7778    @Override
    7879    public void run() {
    79         Main.debug("Load Thumbnails");
     80        Logging.debug("Load Thumbnails");
    8081        tracker = new MediaTracker(Main.map.mapView);
    8182        for (ImageEntry entry : data) {
     
    104105                BufferedImageCacheEntry cacheEntry = cache.get(cacheIdent);
    105106                if (cacheEntry != null && cacheEntry.getImage() != null) {
    106                     Main.debug(" from cache");
     107                    Logging.debug(" from cache");
    107108                    return cacheEntry.getImage();
    108109                }
    109110            } catch (IOException e) {
    110                 Main.warn(e);
     111                Logging.warn(e);
    111112            }
    112113        }
     
    117118            tracker.waitForID(0);
    118119        } catch (InterruptedException e) {
    119             Main.error(" InterruptedException while loading thumb");
     120            Logging.error(" InterruptedException while loading thumb");
    120121            Thread.currentThread().interrupt();
    121122            return null;
    122123        }
    123124        if (tracker.isErrorID(1) || img.getWidth(null) <= 0 || img.getHeight(null) <= 0) {
    124             Main.error(" Invalid image");
     125            Logging.error(" Invalid image");
    125126            return null;
    126127        }
     
    154155                Thread.sleep(10);
    155156            } catch (InterruptedException e) {
    156                 Main.warn("InterruptedException while drawing thumb");
     157                Logging.warn("InterruptedException while drawing thumb");
    157158                Thread.currentThread().interrupt();
    158159            }
     
    162163
    163164        if (scaledBI.getWidth() <= 0 || scaledBI.getHeight() <= 0) {
    164             Main.error(" Invalid image");
     165            Logging.error(" Invalid image");
    165166            return null;
    166167        }
     
    171172                cache.put(cacheIdent, new BufferedImageCacheEntry(output.toByteArray()));
    172173            } catch (IOException e) {
    173                 Main.warn("Failed to save geoimage thumb to cache");
    174                 Main.warn(e);
     174                Logging.warn("Failed to save geoimage thumb to cache");
     175                Logging.warn(e);
    175176            }
    176177        }
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ConvertToDataLayerAction.java

    r12156 r12620  
    3737import org.openstreetmap.josm.tools.GBC;
    3838import org.openstreetmap.josm.tools.ImageProvider;
     39import org.openstreetmap.josm.tools.Logging;
    3940import org.openstreetmap.josm.tools.UncheckedParseException;
    4041import org.openstreetmap.josm.tools.date.DateUtils;
     
    8485                                n.setTimestamp(DateUtils.fromString(timestr));
    8586                            } catch (UncheckedParseException e) {
    86                                 Main.warn(e, false);
     87                                Logging.log(Logging.LEVEL_WARN, e);
    8788                            }
    8889                        }
     
    133134                    }
    134135                } else {
    135                     Main.warn("Invalid gpx.to-osm-mapping Einstein setting: expecting even number of entries");
     136                    Logging.warn("Invalid gpx.to-osm-mapping Einstein setting: expecting even number of entries");
    136137                }
    137138                ds.addPrimitive(node);
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadWmsAlongTrackAction.java

    r12355 r12620  
    2727import org.openstreetmap.josm.io.OsmTransferException;
    2828import org.openstreetmap.josm.tools.ImageProvider;
     29import org.openstreetmap.josm.tools.Logging;
    2930import org.xml.sax.SAXException;
    3031
     
    6667                    }
    6768                } catch (InterruptedException ex) {
    68                     Main.warn("InterruptedException in "+getClass().getSimpleName()+" while precaching WMS");
     69                    Logging.warn("InterruptedException in "+getClass().getSimpleName()+" while precaching WMS");
    6970                    Thread.currentThread().interrupt();
    7071                }
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java

    r12367 r12620  
    5555import org.openstreetmap.josm.tools.ColorScale;
    5656import org.openstreetmap.josm.tools.JosmRuntimeException;
     57import org.openstreetmap.josm.tools.Logging;
    5758import org.openstreetmap.josm.tools.Utils;
    5859
     
    280281            return ColorMode.fromIndex(i);
    281282        } catch (IndexOutOfBoundsException e) {
    282             Main.warn(e);
     283            Logging.warn(e);
    283284        }
    284285        return ColorMode.NONE;
     
    472473
    473474        // show some debug info
    474         if (Main.isDebugEnabled() && !visibleSegments.isEmpty()) {
     475        if (Logging.isDebugEnabled() && !visibleSegments.isEmpty()) {
    475476            final long timeDiff = System.currentTimeMillis() - timeStart;
    476477
    477             Main.debug("gpxdraw::draw takes " +
     478            Logging.debug("gpxdraw::draw takes " +
    478479                         Utils.getDurationString(timeDiff) +
    479480                         "(" +
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/ColorfulFilter.java

    r12102 r12620  
    1313import java.util.Optional;
    1414
    15 import org.openstreetmap.josm.Main;
     15import org.openstreetmap.josm.tools.Logging;
    1616
    1717/**
     
    4040        DataBuffer destBuffer = dest.getRaster().getDataBuffer();
    4141        if (!(srcBuffer instanceof DataBufferByte) || !(destBuffer instanceof DataBufferByte)) {
    42             Main.trace("Cannot apply color filter: Images do not use DataBufferByte.");
     42            Logging.trace("Cannot apply color filter: Images do not use DataBufferByte.");
    4343            return src;
    4444        }
     
    4646        int type = src.getType();
    4747        if (type != dest.getType()) {
    48             Main.trace("Cannot apply color filter: Src / Dest differ in type (" + type + '/' + dest.getType() + ')');
     48            Logging.trace("Cannot apply color filter: Src / Dest differ in type (" + type + '/' + dest.getType() + ')');
    4949            return src;
    5050        }
     
    7373            break;
    7474        default:
    75             Main.trace("Cannot apply color filter: Source image is of wrong type (" + type + ").");
     75            Logging.trace("Cannot apply color filter: Source image is of wrong type (" + type + ").");
    7676            return src;
    7777        }
     
    8686        byte[] destPixels = dest.getData();
    8787        if (srcPixels.length != destPixels.length) {
    88             Main.trace("Cannot apply color filter: Source/Dest lengths differ.");
     88            Logging.trace("Cannot apply color filter: Source/Dest lengths differ.");
    8989            return;
    9090        }
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/ColorfulImageProcessor.java

    r12597 r12620  
    66import java.util.Map;
    77
    8 import org.openstreetmap.josm.Main;
    98import org.openstreetmap.josm.gui.layer.ImageProcessor;
    109import org.openstreetmap.josm.io.session.SessionAwareReadApply;
     10import org.openstreetmap.josm.tools.Logging;
    1111import org.openstreetmap.josm.tools.Utils;
    1212
     
    6363                setColorfulness(Double.parseDouble(cStr));
    6464            } catch (NumberFormatException e) {
    65                 if (Main.isTraceEnabled()) {
    66                     Main.trace(e);
    67                 }
     65                Logging.trace(e);
    6866            }
    6967        }
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/GammaImageProcessor.java

    r12597 r12620  
    99import java.util.Map;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.gui.layer.ImageProcessor;
    1312import org.openstreetmap.josm.io.session.SessionAwareReadApply;
     13import org.openstreetmap.josm.tools.Logging;
    1414import org.openstreetmap.josm.tools.Utils;
    1515
     
    5858            }
    5959        } catch (IllegalArgumentException ignore) {
    60             Main.trace(ignore);
     60            Logging.trace(ignore);
    6161        }
    6262        final int type = image.getTransparency() == Transparency.OPAQUE ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
     
    7373                setGamma(Double.parseDouble(cStr));
    7474            } catch (NumberFormatException e) {
    75                 if (Main.isTraceEnabled()) {
    76                     Main.trace(e);
    77                 }
     75                Logging.trace(e);
    7876            }
    7977        }
  • trunk/src/org/openstreetmap/josm/gui/layer/imagery/SharpenImageProcessor.java

    r12597 r12620  
    88import java.util.Map;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.gui.layer.ImageProcessor;
    1211import org.openstreetmap.josm.io.session.SessionAwareReadApply;
     12import org.openstreetmap.josm.tools.Logging;
    1313import org.openstreetmap.josm.tools.Utils;
    1414
     
    100100                setSharpenLevel(Float.parseFloat(vStr));
    101101            } catch (NumberFormatException e) {
    102                 if (Main.isTraceEnabled()) {
    103                     Main.trace(e);
    104                 }
     102                Logging.trace(e);
    105103            }
    106104        }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/DefaultMarkerProducers.java

    r12328 r12620  
    1010import java.util.Optional;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.data.gpx.Extensions;
    1413import org.openstreetmap.josm.data.gpx.GpxConstants;
    1514import org.openstreetmap.josm.data.gpx.GpxLink;
    1615import org.openstreetmap.josm.data.gpx.WayPoint;
     16import org.openstreetmap.josm.tools.Logging;
    1717import org.openstreetmap.josm.tools.Utils;
    1818
     
    5151                    audioMarker.syncOffset = Double.parseDouble(exts.get("sync-offset"));
    5252                } catch (NumberFormatException nfe) {
    53                     Main.warn(nfe);
     53                    Logging.warn(nfe);
    5454                }
    5555            }
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java

    r12328 r12620  
    2323import javax.swing.ImageIcon;
    2424
    25 import org.openstreetmap.josm.Main;
    2625import org.openstreetmap.josm.actions.search.SearchCompiler.Match;
    2726import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
     
    3534import org.openstreetmap.josm.gui.MapView;
    3635import org.openstreetmap.josm.tools.ImageProvider;
     36import org.openstreetmap.josm.tools.Logging;
    3737import org.openstreetmap.josm.tools.template_engine.ParseError;
    3838import org.openstreetmap.josm.tools.template_engine.TemplateEngineDataProvider;
     
    145145                return new TemplateParser(s).parse();
    146146            } catch (ParseError e) {
    147                 Main.debug(e);
    148                 Main.warn("Unable to parse template engine pattern ''{0}'' for property {1}. Using default (''{2}'') instead",
     147                Logging.debug(e);
     148                Logging.warn("Unable to parse template engine pattern ''{0}'' for property {1}. Using default (''{2}'') instead",
    149149                        s, getKey(), super.getDefaultValueAsString());
    150150                return getDefaultValue();
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

    r12340 r12620  
    5151import org.openstreetmap.josm.io.audio.AudioPlayer;
    5252import org.openstreetmap.josm.tools.ImageProvider;
     53import org.openstreetmap.josm.tools.Logging;
    5354import org.openstreetmap.josm.tools.Utils;
    5455
     
    127128                    offset = Double.valueOf(exts.get("offset"));
    128129                } catch (NumberFormatException nfe) {
    129                     Main.warn(nfe);
     130                    Logging.warn(nfe);
    130131                }
    131132            }
     
    276277            }
    277278        } catch (URISyntaxException e) {
    278             Main.warn(e);
     279            Logging.warn(e);
    279280        }
    280281        return true;
  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/WebMarker.java

    r10212 r12620  
    1111import javax.swing.JOptionPane;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.data.coor.LatLon;
    1514import org.openstreetmap.josm.data.gpx.GpxConstants;
     
    1817import org.openstreetmap.josm.gui.Notification;
    1918import org.openstreetmap.josm.tools.CheckParameterUtil;
     19import org.openstreetmap.josm.tools.Logging;
    2020import org.openstreetmap.josm.tools.OpenBrowser;
    2121
     
    6767                setErroneous(path.isEmpty() || !new File(path).exists());
    6868            } catch (SecurityException e) {
    69                 Main.warn(e);
     69                Logging.warn(e);
    7070                setErroneous(true);
    7171            }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/Cascade.java

    r12378 r12620  
    1111import java.util.regex.Pattern;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.gui.mappaint.mapcss.CSSColors;
    1514import org.openstreetmap.josm.tools.ColorHelper;
     15import org.openstreetmap.josm.tools.Logging;
    1616import org.openstreetmap.josm.tools.Utils;
    1717
     
    7575        if (res == null) {
    7676            if (!suppressWarnings) {
    77                 Main.warn(String.format("Unable to convert property %s to type %s: found %s of type %s!", key, klass, o, o.getClass()));
     77                Logging.warn(String.format("Unable to convert property %s to type %s: found %s of type %s!", key, klass, o, o.getClass()));
    7878            }
    7979            return def;
     
    181181                return Float.valueOf((String) o);
    182182            } catch (NumberFormatException e) {
    183                 if (Main.isDebugEnabled()) {
    184                     Main.debug('\'' + (String) o + "' cannot be converted to float");
    185                 }
     183                Logging.debug("'{0}' cannot be converted to float", o);
    186184            }
    187185        }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/MapPaintStyles.java

    r12410 r12620  
    3535import org.openstreetmap.josm.tools.ImageProvider;
    3636import org.openstreetmap.josm.tools.ListenerList;
     37import org.openstreetmap.josm.tools.Logging;
    3738import org.openstreetmap.josm.tools.Utils;
    3839
     
    157158            String msg = "Mappaint style \""+namespace+"\" ("+ref.source.getDisplayString()+") icon \"" + ref.iconName + "\" not found.";
    158159            ref.source.logWarning(msg);
    159             Main.warn(msg);
     160            Logging.warn(msg);
    160161            return null;
    161162        }
     
    176177        ImageIcon i = getIconProvider(ref, false).setSize(width, height).get();
    177178        if (i == null) {
    178             Main.warn("Mappaint style \""+namespace+"\" ("+ref.source.getDisplayString()+") icon \"" + ref.iconName + "\" not found.");
     179            Logging.warn("Mappaint style \""+namespace+"\" ("+ref.source.getDisplayString()+") icon \"" + ref.iconName + "\" not found.");
    179180            return null;
    180181        }
     
    308309                Main.fileWatcher.registerStyleSource(source);
    309310            } catch (IOException | IllegalStateException | IllegalArgumentException e) {
    310                 Main.error(e);
    311             }
    312         }
    313         if (Main.isDebugEnabled() || !source.isValid()) {
     311                Logging.error(e);
     312            }
     313        }
     314        if (Logging.isDebugEnabled() || !source.isValid()) {
    314315            final long elapsedTime = System.currentTimeMillis() - startTime;
    315316            String message = "Initializing map style " + source.url + " completed in " + Utils.getDurationString(elapsedTime);
    316317            if (!source.isValid()) {
    317                 Main.warn(message + " (" + source.getErrors().size() + " errors, " + source.getWarnings().size() + " warnings)");
     318                Logging.warn(message + " (" + source.getErrors().size() + " errors, " + source.getWarnings().size() + " warnings)");
    318319            } else {
    319                 Main.debug(message);
     320                Logging.debug(message);
    320321            }
    321322        }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/StyleSetting.java

    r12378 r12620  
    1111
    1212import org.openstreetmap.josm.Main;
     13import org.openstreetmap.josm.tools.Logging;
    1314
    1415/**
     
    8081            String label = c.get("label", null, String.class);
    8182            if (label == null) {
    82                 Main.warn("property 'label' required for boolean style setting");
     83                Logging.warn("property 'label' required for boolean style setting");
    8384                return null;
    8485            }
    8586            Boolean def = c.get("default", null, Boolean.class);
    8687            if (def == null) {
    87                 Main.warn("property 'default' required for boolean style setting");
     88                Logging.warn("property 'default' required for boolean style setting");
    8889                return null;
    8990            }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

    r12533 r12620  
    2424import java.util.zip.CRC32;
    2525
    26 import org.openstreetmap.josm.Main;
    2726import org.openstreetmap.josm.actions.search.SearchCompiler;
    2827import org.openstreetmap.josm.actions.search.SearchCompiler.Match;
     
    4140import org.openstreetmap.josm.tools.Geometry;
    4241import org.openstreetmap.josm.tools.JosmRuntimeException;
     42import org.openstreetmap.josm.tools.Logging;
    4343import org.openstreetmap.josm.tools.RightAndLefthandTraffic;
    4444import org.openstreetmap.josm.tools.SubclassFilteredCollection;
     
    266266                return new Color(r, g, b);
    267267            } catch (IllegalArgumentException e) {
    268                 Main.trace(e);
     268                Logging.trace(e);
    269269                return null;
    270270            }
     
    285285                return new Color(r, g, b, alpha);
    286286            } catch (IllegalArgumentException e) {
    287                 Main.trace(e);
     287                Logging.trace(e);
    288288                return null;
    289289            }
     
    301301                return Color.getHSBColor(h, s, b);
    302302            } catch (IllegalArgumentException e) {
    303                 Main.trace(e);
     303                Logging.trace(e);
    304304                return null;
    305305            }
     
    636636                return RotationAngle.parseCardinalRotation(cardinal);
    637637            } catch (IllegalArgumentException ignore) {
    638                 Main.trace(ignore);
     638                Logging.trace(ignore);
    639639                return null;
    640640            }
     
    677677                m = SearchCompiler.compile(searchStr);
    678678            } catch (ParseError ex) {
    679                 Main.trace(ex);
     679                Logging.trace(ex);
    680680                return null;
    681681            }
     
    876876                return Utils.decodeUrl(s);
    877877            } catch (IllegalStateException e) {
    878                 Main.debug(e);
     878                Logging.debug(e);
    879879                return s;
    880880            }
     
    13101310                throw new JosmRuntimeException(ex);
    13111311            } catch (InvocationTargetException ex) {
    1312                 Main.error(ex);
     1312                Logging.error(ex);
    13131313                return null;
    13141314            }
     
    13811381                throw new JosmRuntimeException(ex);
    13821382            } catch (InvocationTargetException ex) {
    1383                 Main.error(ex);
     1383                Logging.error(ex);
    13841384                return null;
    13851385            }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSParser.jj

    r11713 r12620  
    1818import java.util.Locale;
    1919
    20 import org.openstreetmap.josm.Main;
    2120import org.openstreetmap.josm.data.preferences.ColorProperty;
    2221import org.openstreetmap.josm.gui.mappaint.Keyword;
     
    4241import org.openstreetmap.josm.tools.ColorHelper;
    4342import org.openstreetmap.josm.tools.JosmRuntimeException;
     43import org.openstreetmap.josm.tools.Logging;
    4444import org.openstreetmap.josm.tools.Pair;
    4545import org.openstreetmap.josm.tools.Utils;
     
    394394            String msg = tr("Detected deprecated ''{0}'' in ''{1}'' which will be removed shortly. Use ''{2}'' instead.",
    395395                            "@media", sheet.getDisplayString(), "@supports");
    396             Main.error(msg);
     396            Logging.error(msg);
    397397            sheet.logWarning(msg);
    398398        }
     
    626626            rule() w()
    627627        } catch (MapCSSException mex) {
    628             Main.error(mex);
     628            Logging.error(mex);
    629629            error_skipto(RBRACE, mex);
    630630            w();
     
    12071207    }
    12081208   
    1209     Main.error("Skipping to the next rule, because of an error:");
    1210     Main.error(e);
     1209    Logging.error("Skipping to the next rule, because of an error:");
     1210    Logging.error(e);
    12111211    if (sheet != null) {
    12121212        sheet.logError(e);
     
    12321232                t.image.contains("\n")) {
    12331233            ParseException e = new ParseException(String.format("Warning: end of line while reading an unquoted string at line %s column %s.", t.beginLine, t.beginColumn));
    1234             Main.error(e);
     1234            Logging.error(e);
    12351235            if (sheet != null) {
    12361236                sheet.logError(e);
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSStyleSource.java

    r12379 r12620  
    2929import java.util.zip.ZipFile;
    3030
    31 import org.openstreetmap.josm.Main;
    3231import org.openstreetmap.josm.data.Version;
    3332import org.openstreetmap.josm.data.osm.AbstractPrimitive;
     
    6261import org.openstreetmap.josm.tools.JosmRuntimeException;
    6362import org.openstreetmap.josm.tools.LanguageInfo;
     63import org.openstreetmap.josm.tools.Logging;
    6464import org.openstreetmap.josm.tools.Utils;
    6565
     
    437437                }
    438438            } catch (IOException e) {
    439                 Main.warn(tr("Failed to load Mappaint styles from ''{0}''. Exception was: {1}", url, e.toString()));
    440                 Main.error(e);
     439                Logging.warn(tr("Failed to load Mappaint styles from ''{0}''. Exception was: {1}", url, e.toString()));
     440                Logging.error(e);
    441441                logError(e);
    442442            } catch (TokenMgrError e) {
    443                 Main.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
    444                 Main.error(e);
     443                Logging.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
     444                Logging.error(e);
    445445                logError(e);
    446446            } catch (ParseException e) {
    447                 Main.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
    448                 Main.error(e);
     447                Logging.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
     448                Logging.error(e);
    449449                logError(new ParseException(e.getMessage())); // allow e to be garbage collected, it links to the entire token stream
    450450            }
     
    489489                    default:
    490490                        final RuntimeException e = new JosmRuntimeException(MessageFormat.format("Unknown MapCSS base selector {0}", base));
    491                         Main.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
    492                         Main.error(e);
     491                        Logging.warn(tr("Failed to parse Mappaint styles from ''{0}''. Error was: {1}", url, e.getMessage()));
     492                        Logging.error(e);
    493493                        logError(e);
    494494                }
     
    583583        for (Entry<String, Cascade> e : mc.getLayers()) {
    584584            if ("default".equals(e.getKey())) {
    585                 Main.warn("setting requires layer identifier e.g. 'setting::my_setting {...}'");
     585                Logging.warn("setting requires layer identifier e.g. 'setting::my_setting {...}'");
    586586                continue;
    587587            }
     
    592592                set = BooleanStyleSetting.create(c, this, e.getKey());
    593593            } else {
    594                 Main.warn("Unkown setting type: "+type);
     594                Logging.warn("Unkown setting type: "+type);
    595595            }
    596596            if (set != null) {
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/Selector.java

    r12544 r12620  
    1313import java.util.regex.PatternSyntaxException;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.data.osm.Node;
    1716import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2726import org.openstreetmap.josm.tools.CheckParameterUtil;
    2827import org.openstreetmap.josm.tools.Geometry;
     28import org.openstreetmap.josm.tools.Logging;
    2929import org.openstreetmap.josm.tools.Pair;
    3030import org.openstreetmap.josm.tools.SubclassFilteredCollection;
     
    336336                    };
    337337                } catch (NoSuchElementException ignore) {
    338                     Main.trace(ignore);
     338                    Logging.trace(ignore);
    339339                    containsFinder = new ContainsFinder(e);
    340340                }
     
    473473                    if (!c.applies(env)) return false;
    474474                } catch (PatternSyntaxException e) {
    475                     Main.error(e, "PatternSyntaxException while applying condition" + c + ':');
     475                    Logging.log(Logging.LEVEL_ERROR, "PatternSyntaxException while applying condition" + c + ':', e);
    476476                    return false;
    477477                }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/LineElement.java

    r12303 r12620  
    88import java.util.Optional;
    99
    10 import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.data.osm.Node;
    1211import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2019import org.openstreetmap.josm.gui.mappaint.MultiCascade;
    2120import org.openstreetmap.josm.gui.mappaint.mapcss.Instruction.RelativeFloat;
     21import org.openstreetmap.josm.tools.Logging;
    2222import org.openstreetmap.josm.tools.Utils;
    2323
     
    456456                    realWidth = Float.parseFloat(widthTag);
    457457                } catch (NumberFormatException nfe) {
    458                     Main.warn(nfe);
     458                    Logging.warn(nfe);
    459459                }
    460460            }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/NodeElement.java

    r12303 r12620  
    2727import org.openstreetmap.josm.gui.util.RotationAngle;
    2828import org.openstreetmap.josm.tools.CheckParameterUtil;
     29import org.openstreetmap.josm.tools.Logging;
    2930import org.openstreetmap.josm.tools.Utils;
    3031
     
    130131                        rotationAngle = RotationAngle.buildStaticRotation(rotationKW.val);
    131132                    } catch (IllegalArgumentException ignore) {
    132                         Main.trace(ignore);
     133                        Logging.trace(ignore);
    133134                    }
    134135                }
  • trunk/src/org/openstreetmap/josm/gui/oauth/FullyAutomaticAuthorizationUI.java

    r11848 r12620  
    2929import javax.swing.text.html.HTMLEditorKit;
    3030
    31 import org.openstreetmap.josm.Main;
    3231import org.openstreetmap.josm.data.Preferences;
    3332import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    5049import org.openstreetmap.josm.io.auth.CredentialsManager;
    5150import org.openstreetmap.josm.tools.ImageProvider;
     51import org.openstreetmap.josm.tools.Logging;
    5252import org.openstreetmap.josm.tools.Utils;
    5353import org.xml.sax.SAXException;
     
    185185            }
    186186        } catch (CredentialsAgentException e) {
    187             Main.error(e);
     187            Logging.error(e);
    188188            tfUserName.setText("");
    189189            tfPassword.setText("");
     
    472472                }
    473473            };
    474             Main.error(e);
     474            Logging.error(e);
    475475            GuiHelper.runInEDT(r);
    476476        }
  • trunk/src/org/openstreetmap/josm/gui/oauth/OsmOAuthAuthorizationClient.java

    r12204 r12620  
    2020import java.util.regex.Pattern;
    2121
    22 import org.openstreetmap.josm.Main;
    2322import org.openstreetmap.josm.data.oauth.OAuthParameters;
    2423import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    2928import org.openstreetmap.josm.tools.CheckParameterUtil;
    3029import org.openstreetmap.josm.tools.HttpClient;
     30import org.openstreetmap.josm.tools.Logging;
    3131import org.openstreetmap.josm.tools.Utils;
    3232
     
    180180            }
    181181        } catch (IOException e) {
    182             Main.error(e);
     182            Logging.error(e);
    183183            return null;
    184184        }
    185         Main.warn("No authenticity_token found in response!");
     185        Logging.warn("No authenticity_token found in response!");
    186186        return null;
    187187    }
     
    193193                .get("Cookie");
    194194        if (setCookies == null) {
    195             Main.warn("No 'Set-Cookie' in response header!");
     195            Logging.warn("No 'Set-Cookie' in response header!");
    196196            return null;
    197197        }
     
    220220            }
    221221        }
    222         Main.warn("No suitable 'Set-Cookie' in response header found! {0}", setCookies);
     222        Logging.warn("No suitable 'Set-Cookie' in response header found! {0}", setCookies);
    223223        return null;
    224224    }
     
    329329                        userName));
    330330        } catch (OsmOAuthAuthorizationException e) {
    331             Main.debug(e);
     331            Logging.debug(e);
    332332            throw new OsmLoginFailedException(e.getCause());
    333333        } catch (IOException e) {
  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveAccessTokenTask.java

    r11604 r12620  
    99import javax.swing.JOptionPane;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.data.oauth.OAuthParameters;
    1312import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    1918import org.openstreetmap.josm.io.OsmTransferException;
    2019import org.openstreetmap.josm.tools.CheckParameterUtil;
     20import org.openstreetmap.josm.tools.Logging;
    2121import org.xml.sax.SAXException;
    2222
     
    8787            accessToken = client.getAccessToken(getProgressMonitor().createSubTaskMonitor(0, false));
    8888        } catch (OsmTransferCanceledException e) {
    89             Main.trace(e);
     89            Logging.trace(e);
    9090            return;
    9191        } catch (final OsmOAuthAuthorizationException e) {
    92             Main.error(e);
     92            Logging.error(e);
    9393            GuiHelper.runInEDT(this::alertRetrievingAccessTokenFailed);
    9494            accessToken = null;
  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveRequestTokenTask.java

    r11604 r12620  
    99import javax.swing.JOptionPane;
    1010
    11 import org.openstreetmap.josm.Main;
    1211import org.openstreetmap.josm.data.oauth.OAuthParameters;
    1312import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    1918import org.openstreetmap.josm.io.OsmTransferException;
    2019import org.openstreetmap.josm.tools.CheckParameterUtil;
     20import org.openstreetmap.josm.tools.Logging;
    2121import org.xml.sax.SAXException;
    2222
     
    8181            requestToken = client.getRequestToken(getProgressMonitor().createSubTaskMonitor(0, false));
    8282        } catch (OsmTransferCanceledException e) {
    83             Main.trace(e);
     83            Logging.trace(e);
    8484            return;
    8585        } catch (final OsmOAuthAuthorizationException e) {
    86             Main.error(e);
     86            Logging.error(e);
    8787            GuiHelper.runInEDT(this::alertRetrievingRequestTokenFailed);
    8888            requestToken = null;
  • trunk/src/org/openstreetmap/josm/gui/oauth/TestAccessTokenTask.java

    r11848 r12620  
    1212import javax.xml.parsers.ParserConfigurationException;
    1313
    14 import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.data.oauth.OAuthParameters;
    1615import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    2524import org.openstreetmap.josm.tools.CheckParameterUtil;
    2625import org.openstreetmap.josm.tools.HttpClient;
     26import org.openstreetmap.josm.tools.Logging;
    2727import org.openstreetmap.josm.tools.Utils;
    2828import org.openstreetmap.josm.tools.XmlParsingException;
     
    253253        } catch (OsmOAuthAuthorizationException e) {
    254254            if (canceled) return;
    255             Main.error(e);
     255            Logging.error(e);
    256256            alertFailedSigning();
    257257        } catch (OsmApiException e) {
    258258            if (canceled) return;
    259             Main.error(e);
     259            Logging.error(e);
    260260            if (e.getResponseCode() == HttpURLConnection.HTTP_INTERNAL_ERROR) {
    261261                alertInternalError();
     
    271271        } catch (OsmTransferException e) {
    272272            if (canceled) return;
    273             Main.error(e);
     273            Logging.error(e);
    274274            alertFailedConnection();
    275275        }
  • trunk/src/org/openstreetmap/josm/gui/preferences/DefaultTabPreferenceSetting.java

    r12460 r12620  
    1010import javax.swing.JTabbedPane;
    1111
    12 import org.openstreetmap.josm.Main;
    1312import org.openstreetmap.josm.tools.GBC;
     13import org.openstreetmap.josm.tools.Logging;
    1414
    1515/**
     
    105105                } catch (IllegalArgumentException e) {
    106106                    // Ignore exception and return false below
    107                     Main.debug(Main.getErrorMessage(e));
     107                    Logging.debug(Logging.getErrorMessage(e));
    108108                }
    109109            }
  • trunk/src/org/openstreetmap/josm/gui/preferences/PreferenceTabbedPane.java

    r12537 r12620  
    6464import org.openstreetmap.josm.tools.GBC;
    6565import org.openstreetmap.josm.tools.ImageProvider;
     66import org.openstreetmap.josm.tools.Logging;
    6667import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    6768
     
    499500                }
    500501            } else if (!(setting instanceof SubPreferenceSetting)) {
    501                 Main.warn("Ignoring preferences "+setting);
     502                Logging.warn("Ignoring preferences "+setting);
    502503            }
    503504        }
     
    507508            }
    508509        } catch (IllegalArgumentException e) {
    509             Main.warn(e);
     510            Logging.warn(e);
    510511        }
    511512    }
     
    600601                    }
    601602                } catch (SecurityException ex) {
    602                     Main.error(ex);
     603                    Logging.error(ex);
    603604                } catch (RuntimeException ex) { // NOPMD
    604605                    // allow to change most settings even if e.g. a plugin fails
     
    617618                sps.addGui(this);
    618619            } catch (SecurityException ex) {
    619                 Main.error(ex);
     620                Logging.error(ex);
    620621            } catch (RuntimeException ex) { // NOPMD
    621622                BugReportExceptionHandler.handleException(ex);
  • trunk/src/org/openstreetmap/josm/gui/preferences/SourceEditor.java

    r12296 r12620  
    9494import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
    9595import org.openstreetmap.josm.tools.LanguageInfo;
     96import org.openstreetmap.josm.tools.Logging;
    9697import org.openstreetmap.josm.tools.Utils;
    9798import org.xml.sax.SAXException;
     
    993994                    break;
    994995                default:
    995                     Main.error("Unsupported source type: "+sourceType);
     996                    Logging.error("Unsupported source type: "+sourceType);
    996997                    return;
    997998                }
     
    15151516                for (Iterator<ExtendedSourceEntry> it = sources.iterator(); it.hasNext();) {
    15161517                    if ("xml".equals(it.next().styleType)) {
    1517                         Main.debug("Removing XML source entry");
     1518                        Logging.debug("Removing XML source entry");
    15181519                        it.remove();
    15191520                    }
     
    15441545                        Matcher m = Pattern.compile("^\t([^:]+): *(.+)$").matcher(line);
    15451546                        if (!m.matches()) {
    1546                             Main.error(tr(getStr(I18nString.ILLEGAL_FORMAT_OF_ENTRY), url, line));
     1547                            Logging.error(tr(getStr(I18nString.ILLEGAL_FORMAT_OF_ENTRY), url, line));
    15471548                            continue;
    15481549                        }
     
    15791580                                } catch (NumberFormatException e) {
    15801581                                    // ignore
    1581                                     Main.trace(e);
     1582                                    Logging.trace(e);
    15821583                                }
    15831584                            } else if ("style-type".equals(key)) {
     
    15921593                            sources.add(last);
    15931594                        } else {
    1594                             Main.error(tr(getStr(I18nString.ILLEGAL_FORMAT_OF_ENTRY), url, line));
     1595                            Logging.error(tr(getStr(I18nString.ILLEGAL_FORMAT_OF_ENTRY), url, line));
    15951596                        }
    15961597                    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/SourceEntry.java

    r9371 r12620  
    77import java.util.regex.Pattern;
    88
    9 import org.openstreetmap.josm.Main;
     9import org.openstreetmap.josm.tools.Logging;
    1010import org.openstreetmap.josm.tools.Utils;
    1111
     
    153153            return m.group(1);
    154154        } else {
    155             Main.warn("Unexpected URL format: "+url);
     155            Logging.warn("Unexpected URL format: "+url);
    156156            return url;
    157157        }
  • trunk/src/org/openstreetmap/josm/gui/preferences/ToolbarPreferences.java

    r12292 r12620  
    7272import org.openstreetmap.josm.tools.GBC;
    7373import org.openstreetmap.josm.tools.ImageProvider;
     74import org.openstreetmap.josm.tools.Logging;
    7475import org.openstreetmap.josm.tools.Shortcut;
    7576
     
    662663                    return true;
    663664                } catch (IOException | UnsupportedFlavorException e) {
    664                     Main.error(e);
     665                    Logging.error(e);
    665666                }
    666667                return false;
     
    681682                        }
    682683                    } catch (IOException | UnsupportedFlavorException e) {
    683                         Main.error(e);
     684                        Logging.error(e);
    684685                    }
    685686                    movingComponent = "";
     
    10221023                    Object tb = action.getValue("toolbar");
    10231024                    if (tb == null) {
    1024                         Main.info(tr("Toolbar action without name: {0}",
     1025                        Logging.info(tr("Toolbar action without name: {0}",
    10251026                        action.getClass().getName()));
    10261027                        continue;
    10271028                    } else if (!(tb instanceof String)) {
    10281029                        if (!(tb instanceof Boolean) || (Boolean) tb) {
    1029                             Main.info(tr("Strange toolbar value: {0}",
     1030                            Logging.info(tr("Strange toolbar value: {0}",
    10301031                            action.getClass().getName()));
    10311032                        }
     
    10351036                        Action r = actions.get(toolbar);
    10361037                        if (r != null && r != action && !toolbar.startsWith(IMAGERY_PREFIX)) {
    1037                             Main.info(tr("Toolbar action {0} overwritten: {1} gets {2}",
     1038                            Logging.info(tr("Toolbar action {0} overwritten: {1} gets {2}",
    10381039                            toolbar, r.getClass().getName(), action.getClass().getName()));
    10391040                        }
     
    10961097                    result.add(a);
    10971098                } else {
    1098                     Main.info("Could not load tool definition "+s);
     1099                    Logging.info("Could not load tool definition "+s);
    10991100                }
    11001101            }
     
    11121113        String toolbar = (String) action.getValue("toolbar");
    11131114        if (toolbar == null) {
    1114             Main.info(tr("Registered toolbar action without name: {0}",
     1115            Logging.info(tr("Registered toolbar action without name: {0}",
    11151116                action.getClass().getName()));
    11161117        } else {
    11171118            Action r = regactions.get(toolbar);
    11181119            if (r != null) {
    1119                 Main.info(tr("Registered toolbar action {0} overwritten: {1} gets {2}",
     1120                Logging.info(tr("Registered toolbar action {0} overwritten: {1} gets {2}",
    11201121                    toolbar, r.getClass().getName(), action.getClass().getName()));
    11211122            }
  • trunk/src/org/openstreetmap/josm/gui/preferences/advanced/AdvancedPreference.java

    r10627 r12620  
    5151import org.openstreetmap.josm.gui.widgets.JosmTextField;
    5252import org.openstreetmap.josm.tools.GBC;
     53import org.openstreetmap.josm.tools.Logging;
    5354import org.openstreetmap.josm.tools.Utils;
    5455
     
    338339                        Main.pref.save();
    339340                    } catch (IOException e) {
    340                         Main.warn(e, "IOException while saving preferences:");
     341                        Logging.log(Logging.LEVEL_WARN, "IOException while saving preferences:", e);
    341342                    }
    342343                    readPreferences(Main.pref);
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/ColorPreference.java

    r11806 r12620  
    4848import org.openstreetmap.josm.tools.ColorHelper;
    4949import org.openstreetmap.josm.tools.GBC;
     50import org.openstreetmap.josm.tools.Logging;
    5051
    5152/**
     
    118119            Color color = ColorHelper.html2color(html);
    119120            if (color == null) {
    120                 Main.warn("Unable to get color from '"+html+"' for color preference '"+value+'\'');
     121                Logging.warn("Unable to get color from '"+html+"' for color preference '"+value+'\'');
    121122            }
    122123            row.add(value);
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java

    r11568 r12620  
    3232import org.openstreetmap.josm.gui.widgets.JosmTextField;
    3333import org.openstreetmap.josm.tools.GBC;
     34import org.openstreetmap.josm.tools.Logging;
    3435import org.openstreetmap.josm.tools.template_engine.ParseError;
    3536import org.openstreetmap.josm.tools.template_engine.TemplateParser;
     
    430431            case 4: colorTypeTime.setSelected(true); break;
    431432            case 5: colorTypeHeatMap.setSelected(true); break;
    432             default: Main.warn("Unknown color type: " + colorType);
     433            default: Logging.warn("Unknown color type: " + colorType);
    433434            }
    434435            int ccts = Main.pref.getInteger("draw.rawgps.colorTracksTune", layerName, 45);
     
    557558            parser.parse();
    558559        } catch (ParseError e) {
    559             Main.warn(e);
     560            Logging.warn(e);
    560561            JOptionPane.showMessageDialog(Main.parent,
    561562                    tr("Incorrect waypoint label pattern: {0}", e.getMessage()), tr("Incorrect pattern"), JOptionPane.ERROR_MESSAGE);
     
    567568            parser.parse();
    568569        } catch (ParseError e) {
    569             Main.warn(e);
     570            Logging.warn(e);
    570571            JOptionPane.showMessageDialog(Main.parent,
    571572                    tr("Incorrect audio waypoint label pattern: {0}", e.getMessage()), tr("Incorrect pattern"), JOptionPane.ERROR_MESSAGE);
  • trunk/src/org/openstreetmap/josm/gui/preferences/display/LafPreference.java

    r12347 r12620  
    4040import org.openstreetmap.josm.gui.widgets.VerticallyScrollablePanel;
    4141import org.openstreetmap.josm.tools.GBC;
     42import org.openstreetmap.josm.tools.Logging;
    4243import org.openstreetmap.josm.tools.date.DateUtils;
    4344
     
    104105            } catch (ReflectiveOperationException ex) {
    105106                // just debug, Quaqua may not even be installed...
    106                 Main.debug(ex);
     107                Logging.debug(ex);
    107108            }
    108109        }
  • trunk/src/org/openstreetmap/josm/gui/preferences/imagery/AddWMSLayerPanel.java

    r11649 r12620  
    1717import javax.swing.JScrollPane;
    1818
    19 import org.openstreetmap.josm.Main;
    2019import org.openstreetmap.josm.data.imagery.ImageryInfo;
    2120import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryType;
     
    2524import org.openstreetmap.josm.io.imagery.WMSImagery;
    2625import org.openstreetmap.josm.tools.GBC;
     26import org.openstreetmap.josm.tools.Logging;
    2727import org.openstreetmap.josm.tools.Utils;
    2828
     
    7979                formats.setSelectedItem(wms.getPreferredFormats());
    8080            } catch (MalformedURLException ex1) {
    81                 Main.error(ex1, false);
     81                Logging.log(Logging.LEVEL_ERROR, ex1);
    8282                JOptionPane.showMessageDialog(getParent(), tr("Invalid service URL."),
    8383                        tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
    8484            } catch (IOException ex2) {
    85                 Main.error(ex2, false);
     85                Logging.log(Logging.LEVEL_ERROR, ex2);
    8686                JOptionPane.showMessageDialog(getParent(), tr("Could not retrieve WMS layer list."),
    8787                        tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
     
    9090                String title = tr("WMS Error");
    9191                StringBuilder message = new StringBuilder(tr("Could not parse WMS layer list."));
    92                 Main.error(ex3, "Could not parse WMS layer list. Incoming data:\n"+incomingData);
     92                Logging.log(Logging.LEVEL_ERROR, "Could not parse WMS layer list. Incoming data:\n"+incomingData, ex3);
    9393                if ((incomingData.startsWith("<html>") || incomingData.startsWith("<HTML>"))
    9494                  && (incomingData.endsWith("</html>") || incomingData.endsWith("</HTML>"))) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/imagery/CacheContentsPanel.java

    r10647 r12620  
    3535import org.openstreetmap.josm.gui.widgets.ButtonColumn;
    3636import org.openstreetmap.josm.tools.GBC;
     37import org.openstreetmap.josm.tools.Logging;
    3738import org.openstreetmap.josm.tools.Pair;
    3839
     
    9798                }
    9899            } else {
    99                 Main.warn("Could not parse the key: {0}. No colon found", key);
     100                Logging.warn("Could not parse the key: {0}. No colon found", key);
    100101            }
    101102        }
  • trunk/src/org/openstreetmap/josm/gui/preferences/imagery/ImageryPreference.java

    r12093 r12620  
    7272import org.openstreetmap.josm.tools.ImageProvider;
    7373import org.openstreetmap.josm.tools.LanguageInfo;
     74import org.openstreetmap.josm.tools.Logging;
    7475import org.openstreetmap.josm.tools.OpenBrowser;
    7576
     
    791792                    htmlPane = new JosmEditorPane(url);
    792793                } catch (IOException e1) {
    793                     Main.trace(e1);
     794                    Logging.trace(e1);
    794795                    // give a second chance with a default Locale 'en'
    795796                    try {
     
    797798                        htmlPane = new JosmEditorPane(url);
    798799                    } catch (IOException e2) {
    799                         Main.debug(e2);
     800                        Logging.debug(e2);
    800801                        JOptionPane.showMessageDialog(gui, tr("EULA license URL not available: {0}", eulaUrl));
    801802                        return false;
  • trunk/src/org/openstreetmap/josm/gui/preferences/map/MapPaintPreference.java

    r12279 r12620  
    3333import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting;
    3434import org.openstreetmap.josm.tools.GBC;
     35import org.openstreetmap.josm.tools.Logging;
    3536import org.openstreetmap.josm.tools.Utils;
    3637
     
    166167            }
    167168        } catch (RuntimeException ignore) { // NOPMD
    168             Main.debug(ignore);
     169            Logging.debug(ignore);
    169170        }
    170171        return null;
  • trunk/src/org/openstreetmap/josm/gui/preferences/map/TaggingPresetPreference.java

    r12279 r12620  
    3535import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetReader;
    3636import org.openstreetmap.josm.tools.GBC;
     37import org.openstreetmap.josm.tools.Logging;
    3738import org.openstreetmap.josm.tools.Utils;
    3839import org.xml.sax.SAXException;
     
    5859                            canLoad = true;
    5960                        } catch (IOException e) {
    60                             Main.warn(e, tr("Could not read tagging preset source: {0}", source));
     61                            Logging.log(Logging.LEVEL_WARN, tr("Could not read tagging preset source: {0}", source), e);
    6162                            ExtendedDialog ed = new ExtendedDialog(Main.parent, tr("Error"),
    6263                                    tr("Yes"), tr("No"), tr("Cancel"));
     
    7374                        } catch (SAXException e) {
    7475                            // We will handle this in step with validation
    75                             Main.trace(e);
     76                            Logging.trace(e);
    7677                        }
    7778
     
    8384                            // Should not happen, but at least show message
    8485                            String msg = tr("Could not read tagging preset source {0}", source);
    85                             Main.error(e, msg);
     86                            Logging.log(Logging.LEVEL_ERROR, msg, e);
    8687                            JOptionPane.showMessageDialog(Main.parent, msg);
    8788                            return false;
     
    9697                                        source, e.getLineNumber(), e.getColumnNumber(), Utils.escapeReservedCharactersHTML(e.getMessage()));
    9798                            }
    98                             Main.warn(e, errorMessage);
     99                            Logging.log(Logging.LEVEL_WARN, errorMessage, e);
    99100                        } catch (SAXException e) {
    100101                            if (canLoad) {
     
    107108                                        source, Utils.escapeReservedCharactersHTML(e.getMessage()));
    108109                            }
    109                             Main.warn(e, errorMessage);
     110                            Logging.log(Logging.LEVEL_ERROR, errorMessage, e);
    110111                        }
    111112
    112113                        if (errorMessage != null) {
    113                             Main.error(errorMessage);
     114                            Logging.error(errorMessage);
    114115                            int result = JOptionPane.showConfirmDialog(Main.parent, new JLabel(errorMessage), tr("Error"),
    115116                                    JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.ERROR_MESSAGE);
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginPreference.java

    r11636 r12620  
    6262import org.openstreetmap.josm.tools.GBC;
    6363import org.openstreetmap.josm.tools.ImageProvider;
     64import org.openstreetmap.josm.tools.Logging;
    6465import org.openstreetmap.josm.tools.Utils;
    6566
     
    386387                        ));
    387388            } catch (InterruptedException | InvocationTargetException e) {
    388                 Main.error(e);
     389                Logging.error(e);
    389390            }
    390391        }
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginPreferencesModel.java

    r10647 r12620  
    2020import org.openstreetmap.josm.plugins.PluginHandler;
    2121import org.openstreetmap.josm.plugins.PluginInformation;
     22import org.openstreetmap.josm.tools.Logging;
    2223
    2324/**
     
    350351                    }
    351352                } catch (PluginException e) {
    352                     Main.error(e);
     353                    Logging.error(e);
    353354                }
    354355            }
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginUpdatePolicyPanel.java

    r11553 r12620  
    2525import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
    2626import org.openstreetmap.josm.plugins.PluginHandler;
     27import org.openstreetmap.josm.tools.Logging;
    2728
    2829/**
     
    188189            } catch (NumberFormatException e) {
    189190                // ignore - load from preference pluginmanager.time-based-update.interval
    190                 Main.trace(e);
     191                Logging.trace(e);
    191192            }
    192193            if (days <= 0) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/CustomProjectionChoice.java

    r12148 r12620  
    3333import org.openstreetmap.josm.tools.GBC;
    3434import org.openstreetmap.josm.tools.ImageProvider;
     35import org.openstreetmap.josm.tools.Logging;
    3536
    3637/**
     
    104105                        test.update(input.getText());
    105106                    } catch (ProjectionConfigurationException ex) {
    106                         Main.warn(ex);
     107                        Logging.warn(ex);
    107108                        error = ex.getMessage();
    108109                        valStatus.setIcon(ImageProvider.get("data", "error"));
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/GaussKruegerProjectionChoice.java

    r12223 r12620  
    77import java.util.Collections;
    88
    9 import org.openstreetmap.josm.Main;
     9import org.openstreetmap.josm.tools.Logging;
    1010
    1111/**
     
    4040            return Integer.parseInt(zone) - 2;
    4141        } catch (NumberFormatException e) {
    42             Main.warn(e);
     42            Logging.warn(e);
    4343        }
    4444        return defaultIndex;
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/LambertCC9ZonesProjectionChoice.java

    r12280 r12620  
    1111import javax.swing.JPanel;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.tools.GBC;
    1514import org.openstreetmap.josm.tools.ImageProvider;
     15import org.openstreetmap.josm.tools.Logging;
    1616
    1717/**
     
    8383                    return Collections.singleton(String.valueOf(zoneval+1));
    8484            } catch (NumberFormatException ex) {
    85                 Main.warn(ex);
     85                Logging.warn(ex);
    8686            }
    8787        }
     
    9999            return Integer.parseInt(zone) - 1;
    100100        } catch (NumberFormatException e) {
    101             Main.warn(e);
     101            Logging.warn(e);
    102102        }
    103103        return defaultIndex;
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/LambertProjectionChoice.java

    r12537 r12620  
    1111import javax.swing.JPanel;
    1212
    13 import org.openstreetmap.josm.Main;
    1413import org.openstreetmap.josm.tools.GBC;
    1514import org.openstreetmap.josm.tools.ImageProvider;
     15import org.openstreetmap.josm.tools.Logging;
    1616
    1717/**
     
    7777                    return Collections.singleton(zonestring);
    7878            } catch (NumberFormatException e) {
    79                 Main.warn(e);
     79                Logging.warn(e);
    8080            }
    8181        }
     
    9393            return Integer.parseInt(zone) - 1;
    9494        } catch (NumberFormatException e) {
    95             Main.warn(e);
     95            Logging.warn(e);
    9696        }
    9797        return defaultIndex;
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/UTMFranceDOMProjectionChoice.java

    r12537 r12620  
    77import java.util.Collections;
    88
    9 import org.openstreetmap.josm.Main;
     9import org.openstreetmap.josm.tools.Logging;
    1010
    1111/**
     
    4747            return Integer.parseInt(zone) - 1;
    4848        } catch (NumberFormatException e) {
    49             Main.warn(e);
     49            Logging.warn(e);
    5050        }
    5151        return defaultIndex;
  • trunk/src/org/openstreetmap/josm/gui/preferences/projection/UTMProjectionChoice.java

    r12223 r12620  
    1616import javax.swing.JRadioButton;
    1717
    18 import org.openstreetmap.josm.Main;
    1918import org.openstreetmap.josm.tools.GBC;
     19import org.openstreetmap.josm.tools.Logging;
    2020
    2121/**
     
    139139                    return Arrays.asList(zonestring, hem.toString());
    140140            } catch (NumberFormatException e) {
    141                 Main.warn(e);
     141                Logging.warn(e);
    142142            }
    143143        }
     
    170170            return Integer.parseInt(zone) - 1;
    171171        } catch (NumberFormatException e) {
    172             Main.warn(e);
     172            Logging.warn(e);
    173173        }
    174174        return defaultIndex;
  • trunk/src/org/openstreetmap/josm/gui/preferences/remotecontrol/RemoteControlPreference.java

    r10611 r12620  
    3939import org.openstreetmap.josm.io.remotecontrol.handler.RequestHandler;
    4040import org.openstreetmap.josm.tools.GBC;
     41import org.openstreetmap.josm.tools.Logging;
    4142import org.openstreetmap.josm.tools.PlatformHookWindows;
    4243
     
    127128                            tr("Certificate has been successfully installed.") :
    128129                            tr("Certificate is already installed. Nothing to do.");
    129                     Main.info(msg);
     130                    Logging.info(msg);
    130131                    JOptionPane.showMessageDialog(wrapper, msg);
    131132                } catch (IOException | GeneralSecurityException ex) {
    132                     Main.error(ex);
     133                    Logging.error(ex);
    133134                }
    134135            });
     
    138139                    KeyStore ks = PlatformHookWindows.getRootKeystore();
    139140                    if (ks.containsAlias(RemoteControlHttpsServer.ENTRY_ALIAS)) {
    140                         Main.info(tr("Removing certificate {0} from root keystore.", RemoteControlHttpsServer.ENTRY_ALIAS));
     141                        Logging.info(tr("Removing certificate {0} from root keystore.", RemoteControlHttpsServer.ENTRY_ALIAS));
    141142                        ks.deleteEntry(RemoteControlHttpsServer.ENTRY_ALIAS);
    142143                        msg = tr("Certificate has been successfully uninstalled.");
     
    144145                        msg = tr("Certificate is not installed. Nothing to do.");
    145146                    }
    146                     Main.info(msg);
     147                    Logging.info(msg);
    147148                    JOptionPane.showMessageDialog(wrapper, msg);
    148149                } catch (KeyStoreException | NoSuchAlgorithmException | CertificateException | IOException ex) {
    149                     Main.error(ex);
     150                    Logging.error(ex);
    150151                }
    151152            });
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/ApiUrlTestTask.java

    r10627 r12620  
    1313import javax.xml.parsers.ParserConfigurationException;
    1414
    15 import org.openstreetmap.josm.Main;
    1615import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    1716import org.openstreetmap.josm.gui.PleaseWaitRunnable;
     
    2120import org.openstreetmap.josm.tools.CheckParameterUtil;
    2221import org.openstreetmap.josm.tools.HttpClient;
     22import org.openstreetmap.josm.tools.Logging;
    2323import org.xml.sax.InputSource;
    2424import org.xml.sax.SAXException;
     
    191191                Capabilities.CapabilitiesParser.parse(new InputSource(connection.getResponse().getContent()));
    192192            } catch (SAXException | ParserConfigurationException e) {
    193                 Main.warn(e);
     193                Logging.warn(e);
    194194                alertInvalidCapabilities();
    195195                return;
     
    200200                // ignore exceptions
    201201                return;
    202             Main.error(e);
     202            Logging.error(e);
    203203            alertConnectionFailed();
    204204            return;
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/AuthenticationPreferencesPanel.java

    r10179 r12620  
    2323import org.openstreetmap.josm.io.OsmApi;
    2424import org.openstreetmap.josm.io.auth.CredentialsManager;
     25import org.openstreetmap.josm.tools.Logging;
    2526
    2627/**
     
    121122            rbOAuth.setSelected(true);
    122123        } else {
    123             Main.warn(tr("Unsupported value in preference ''{0}'', got ''{1}''. Using authentication method ''Basic Authentication''.",
     124            Logging.warn(tr("Unsupported value in preference ''{0}'', got ''{1}''. Using authentication method ''Basic Authentication''.",
    124125                    "osm-server.auth-method", authMethod));
    125126            rbBasicAuthentication.setSelected(true);
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/BasicAuthenticationPreferencesPanel.java

    r10179 r12620  
    1515import javax.swing.JPanel;
    1616
    17 import org.openstreetmap.josm.Main;
    1817import org.openstreetmap.josm.gui.widgets.JosmPasswordField;
    1918import org.openstreetmap.josm.gui.widgets.JosmTextField;
     
    2322import org.openstreetmap.josm.io.auth.CredentialsAgentException;
    2423import org.openstreetmap.josm.io.auth.CredentialsManager;
     24import org.openstreetmap.josm.tools.Logging;
    2525
    2626/**
     
    107107            }
    108108        } catch (CredentialsAgentException e) {
    109             Main.error(e);
    110             Main.warn(tr("Failed to retrieve OSM credentials from credential manager."));
    111             Main.warn(tr("Current credential manager is of type ''{0}''", cm.getClass().getName()));
     109            Logging.error(e);
     110            Logging.warn(tr("Failed to retrieve OSM credentials from credential manager."));
     111            Logging.warn(tr("Current credential manager is of type ''{0}''", cm.getClass().getName()));
    112112            tfOsmUserName.setText("");
    113113            tfOsmPassword.setText("");
     
    127127            cm.store(RequestorType.SERVER, OsmApi.getOsmApi().getHost(), pa);
    128128        } catch (CredentialsAgentException e) {
    129             Main.error(e);
    130             Main.warn(tr("Failed to save OSM credentials to credential manager."));
    131             Main.warn(tr("Current credential manager is of type ''{0}''", cm.getClass().getName()));
     129            Logging.error(e);
     130            Logging.warn(tr("Failed to save OSM credentials to credential manager."));
     131            Logging.warn(tr("Current credential manager is of type ''{0}''", cm.getClass().getName()));
    132132        }
    133133    }
  • trunk/src/org/openstreetmap/josm/gui/preferences/server/OAuthAccessTokenHolder.java

    r10378 r12620  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import org.openstreetmap.josm.Main;
    76import org.openstreetmap.josm.data.Preferences;
    87import org.openstreetmap.josm.data.oauth.OAuthToken;
     
    109import org.openstreetmap.josm.io.auth.CredentialsAgentException;
    1110import org.openstreetmap.josm.tools.CheckParameterUtil;
     11import org.openstreetmap.josm.tools.Logging;
    1212
    1313/**
     
    154154            token = cm.lookupOAuthAccessToken();
    155155        } catch (CredentialsAgentException e) {