Changeset 10611 in josm


Ignore:
Timestamp:
2016-07-23T18:46:45+02:00 (8 years ago)
Author:
Don-vip
Message:

see #11390 - sonar - squid:S1604 - Java 8: Anonymous inner classes containing only one method should become lambdas

Location:
trunk/src/org/openstreetmap/josm
Files:
155 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r10608 r10611  
    256256     * @see #FLAG_HAS_DIRECTIONS
    257257     */
    258     public static final Predicate<Tag> directionalKeyPredicate = tag -> directionKeys.match(tag);
     258    public static final Predicate<Tag> directionalKeyPredicate = directionKeys::match;
    259259
    260260    /**

  • trunk/src/org/openstreetmap/josm/gui/DefaultNameFormatter.java

    r10378 r10611  
    194194    }
    195195
    196     private final Comparator<Node> nodeComparator = new Comparator<Node>() {
    197         @Override
    198         public int compare(Node n1, Node n2) {
    199             return format(n1).compareTo(format(n2));
    200         }
    201     };
     196    private final Comparator<Node> nodeComparator = (n1, n2) -> format(n1).compareTo(format(n2));
    202197
    203198    @Override
    … …  
    289284    }
    290285
    291     private final Comparator<Way> wayComparator = new Comparator<Way>() {
    292         @Override
    293         public int compare(Way w1, Way w2) {
    294             return format(w1).compareTo(format(w2));
    295         }
    296     };
     286    private final Comparator<Way> wayComparator = (w1, w2) -> format(w1).compareTo(format(w2));
    297287
    298288    @Override
    … …  
    349339    }
    350340
    351     private final Comparator<Relation> relationComparator = new Comparator<Relation>() {
    352         @Override
    353         public int compare(Relation r1, Relation r2) {
    354             //TODO This doesn't work correctly with formatHooks
    355 
    356             TaggingPreset preset1 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r1);
    357             TaggingPreset preset2 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r2);
    358 
    359             if (preset1 != null || preset2 != null) {
    360                 String name1 = formatRelationNameAndType(r1, new StringBuilder(), preset1).toString();
    361                 String name2 = formatRelationNameAndType(r2, new StringBuilder(), preset2).toString();
    362 
    363                 int comp = AlphanumComparator.getInstance().compare(name1, name2);
    364                 if (comp != 0)
    365                     return comp;
    366             } else {
    367 
    368                 String type1 = getRelationTypeName(r1);
    369                 String type2 = getRelationTypeName(r2);
    370 
    371                 int comp = AlphanumComparator.getInstance().compare(type1, type2);
    372                 if (comp != 0)
    373                     return comp;
    374 
    375                 String name1 = getRelationName(r1);
    376                 String name2 = getRelationName(r2);
    377 
    378                 comp = AlphanumComparator.getInstance().compare(name1, name2);
    379                 if (comp != 0)
    380                     return comp;
    381             }
    382 
    383             int comp = Integer.compare(r1.getMembersCount(), r2.getMembersCount());
    384             if (comp != 0)
    385                 return comp;
    386 
    387 
    388             comp = Boolean.compare(r1.hasIncompleteMembers(), r2.hasIncompleteMembers());
    389             if (comp != 0)
    390                 return comp;
    391 
    392             return Long.compare(r1.getUniqueId(), r2.getUniqueId());
    393         }
     341    private final Comparator<Relation> relationComparator = (r1, r2) -> {
     342        //TODO This doesn't work correctly with formatHooks
     343
     344        TaggingPreset preset1 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r1);
     345        TaggingPreset preset2 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r2);
     346
     347        if (preset1 != null || preset2 != null) {
     348            String name11 = formatRelationNameAndType(r1, new StringBuilder(), preset1).toString();
     349            String name21 = formatRelationNameAndType(r2, new StringBuilder(), preset2).toString();
     350
     351            int comp1 = AlphanumComparator.getInstance().compare(name11, name21);
     352            if (comp1 != 0)
     353                return comp1;
     354        } else {
     355
     356            String type1 = getRelationTypeName(r1);
     357            String type2 = getRelationTypeName(r2);
     358
     359            int comp2 = AlphanumComparator.getInstance().compare(type1, type2);
     360            if (comp2 != 0)
     361                return comp2;
     362
     363            String name12 = getRelationName(r1);
     364            String name22 = getRelationName(r2);
     365
     366            comp2 = AlphanumComparator.getInstance().compare(name12, name22);
     367            if (comp2 != 0)
     368                return comp2;
     369        }
     370
     371        int comp3 = Integer.compare(r1.getMembersCount(), r2.getMembersCount());
     372        if (comp3 != 0)
     373            return comp3;
     374
     375
     376        comp3 = Boolean.compare(r1.hasIncompleteMembers(), r2.hasIncompleteMembers());
     377        if (comp3 != 0)
     378            return comp3;
     379
     380        return Long.compare(r1.getUniqueId(), r2.getUniqueId());
    394381    };
    395382
    … …  
    644631     */
    645632    public String formatAsHtmlUnorderedList(Collection<? extends OsmPrimitive> primitives, int maxElements) {
    646         final Collection<String> displayNames = Utils.transform(primitives, new Function<OsmPrimitive, String>() {
    647 
    648             @Override
    649             public String apply(OsmPrimitive x) {
    650                 return x.getDisplayName(DefaultNameFormatter.this);
    651             }
    652         });
     633        final Collection<String> displayNames = Utils.transform(primitives,
     634                (Function<OsmPrimitive, String>) x -> x.getDisplayName(DefaultNameFormatter.this));
    653635        return Utils.joinAsHtmlUnorderedList(Utils.limit(displayNames, maxElements, "..."));
    654636    }

  • trunk/src/org/openstreetmap/josm/gui/ExtendedDialog.java

    r10378 r10611  
    576576    private void requestFocusToDefaultButton() {
    577577        if (defaultButton != null) {
    578             GuiHelper.runInEDT(new Runnable() {
    579                 @Override
    580                 public void run() {
    581                     defaultButton.requestFocusInWindow();
    582                 }
    583             });
     578            GuiHelper.runInEDT(() -> defaultButton.requestFocusInWindow());
    584579        }
    585580    }

  • trunk/src/org/openstreetmap/josm/gui/FileDrop.java

    r10600 r10611  
    1616import java.awt.dnd.DropTargetListener;
    1717import java.awt.dnd.InvalidDnDOperationException;
    18 import java.awt.event.HierarchyEvent;
    19 import java.awt.event.HierarchyListener;
    2018import java.io.BufferedReader;
    2119import java.io.File;
    … …  
    9795                BorderFactory.createMatteBorder(2, 2, 2, 2, defaultBorderColor), // Drag border
    9896                true, // Recursive
    99                 new FileDrop.Listener() {
    100                     @Override
    101                     public void filesDropped(File[] files) {
    102                         // start asynchronous loading of files
    103                         OpenFileAction.OpenFileTask task = new OpenFileAction.OpenFileTask(Arrays.asList(files), null);
    104                         task.setRecordHistory(true);
    105                         Main.worker.submit(task);
    106                     }
     97                files -> {
     98                    // start asynchronous loading of files
     99                    OpenFileAction.OpenFileTask task = new OpenFileAction.OpenFileTask(Arrays.asList(files), null);
     100                    task.setRecordHistory(true);
     101                    Main.worker.submit(task);
    107102                }
    108103        );
    … …  
    173168
    174169        // Listen for hierarchy changes and remove the drop target when the parent gets cleared out.
    175         c.addHierarchyListener(new HierarchyListener() {
    176             @Override
    177             public void hierarchyChanged(HierarchyEvent evt) {
    178                 Main.trace("FileDrop: Hierarchy changed.");
    179                 Component parent = c.getParent();
    180                 if (parent == null) {
    181                     c.setDropTarget(null);
    182                     Main.trace("FileDrop: Drop target cleared from component.");
    183                 } else {
    184                     new DropTarget(c, dropListener);
    185                     Main.trace("FileDrop: Drop target added to component.");
    186                 }
     170        c.addHierarchyListener(evt -> {
     171            Main.trace("FileDrop: Hierarchy changed.");
     172            Component parent = c.getParent();
     173            if (parent == null) {
     174                c.setDropTarget(null);
     175                Main.trace("FileDrop: Drop target cleared from component.");
     176            } else {
     177                new DropTarget(c, dropListener);
     178                Main.trace("FileDrop: Drop target added to component.");
    187179            }
    188180        });

  • trunk/src/org/openstreetmap/josm/gui/GettingStarted.java

    r8846 r10611  
    139139    private void getMOTD() {
    140140        // Asynchronously get MOTD to speed-up JOSM startup
    141         Thread t = new Thread(new Runnable() {
    142             @Override
    143             public void run() {
    144                 if (!contentInitialized && Main.pref.getBoolean("help.displaymotd", true)) {
    145                     try {
    146                         content = new MotdContent().updateIfRequiredString();
    147                         contentInitialized = true;
    148                         ProxyPreference.removeProxyPreferenceListener(GettingStarted.this);
    149                     } catch (IOException ex) {
    150                         Main.warn(tr("Failed to read MOTD. Exception was: {0}", ex.toString()));
    151                         content = "<html>" + STYLE + "<h1>" + "JOSM - " + tr("Java OpenStreetMap Editor")
    152                                 + "</h1>\n<h2 align=\"center\">(" + tr("Message of the day not available") + ")</h2></html>";
    153                         // In case of MOTD not loaded because of proxy error, listen to preference changes to retry after update
    154                         ProxyPreference.addProxyPreferenceListener(GettingStarted.this);
    155                     }
     141        Thread t = new Thread((Runnable) () -> {
     142            if (!contentInitialized && Main.pref.getBoolean("help.displaymotd", true)) {
     143                try {
     144                    content = new MotdContent().updateIfRequiredString();
     145                    contentInitialized = true;
     146                    ProxyPreference.removeProxyPreferenceListener(GettingStarted.this);
     147                } catch (IOException ex) {
     148                    Main.warn(tr("Failed to read MOTD. Exception was: {0}", ex.toString()));
     149                    content = "<html>" + STYLE + "<h1>" + "JOSM - " + tr("Java OpenStreetMap Editor")
     150                            + "</h1>\n<h2 align=\"center\">(" + tr("Message of the day not available") + ")</h2></html>";
     151                    // In case of MOTD not loaded because of proxy error, listen to preference changes to retry after update
     152                    ProxyPreference.addProxyPreferenceListener(GettingStarted.this);
    156153                }
     154            }
    157155
    158                 if (content != null) {
    159                     EventQueue.invokeLater(new Runnable() {
    160                         @Override
    161                         public void run() {
    162                             lg.setText(fixImageLinks(content));
    163                         }
    164                     });
    165                 }
     156            if (content != null) {
     157                EventQueue.invokeLater(() -> lg.setText(fixImageLinks(content)));
    166158            }
    167159        }, "MOTD-Loader");

  • trunk/src/org/openstreetmap/josm/gui/HelpAwareOptionPane.java

    r10378 r10611  
    152152                b.setFocusable(true);
    153153                b.setEnabled(spec.isEnabled());
    154                 spec.addChangeListener(new ChangeListener() {
    155                     @Override public void stateChanged(ChangeEvent e) {
    156                         b.setEnabled(spec.isEnabled());
    157                     }
    158                 });
     154                spec.addChangeListener(e -> b.setEnabled(spec.isEnabled()));
    159155                buttons.add(b);
    160156            }
    … …  
    353349    public static void showMessageDialogInEDT(final Component parentComponent, final Object msg, final String title,
    354350            final int messageType, final String helpTopic) {
    355         GuiHelper.runInEDT(new Runnable() {
    356             @Override
    357             public void run() {
    358                 showOptionDialog(parentComponent, msg, title, messageType, null, null, null, helpTopic);
    359             }
    360         });
     351        GuiHelper.runInEDT(() -> showOptionDialog(parentComponent, msg, title, messageType, null, null, null, helpTopic));
    361352    }
    362353}

  • trunk/src/org/openstreetmap/josm/gui/ImageryMenu.java

    r10378 r10611  
    5454     * (for the preferences). We don't want this in the imagery menu.
    5555     */
    56     public static final Comparator<ImageryInfo> alphabeticImageryComparator = new Comparator<ImageryInfo>() {
    57         @Override
    58         public int compare(ImageryInfo ii1, ImageryInfo ii2) {
    59             return ii1.getName().toLowerCase(Locale.ENGLISH).compareTo(ii2.getName().toLowerCase(Locale.ENGLISH));
    60         }
    61     };
     56    public static final Comparator<ImageryInfo> alphabeticImageryComparator =
     57            (ii1, ii2) -> ii1.getName().toLowerCase(Locale.ENGLISH).compareTo(ii2.getName().toLowerCase(Locale.ENGLISH));
    6258
    6359    private final transient Action offsetAction = new JosmAction(

  • trunk/src/org/openstreetmap/josm/gui/MainApplication.java

    r10508 r10611  
    3434import java.util.Set;
    3535import java.util.TreeSet;
    36 import java.util.concurrent.Callable;
    3736
    3837import javax.swing.JOptionPane;
    … …  
    426425        OAuthAccessTokenHolder.getInstance().init(Main.pref, CredentialsManager.getInstance());
    427426
    428         final SplashScreen splash = GuiHelper.runInEDTAndWaitAndReturn(new Callable<SplashScreen>() {
    429             @Override
    430             public SplashScreen call() {
    431                 return new SplashScreen();
    432             }
    433         });
     427        final SplashScreen splash = GuiHelper.runInEDTAndWaitAndReturn(SplashScreen::new);
    434428        final SplashScreen.SplashProgressMonitor monitor = splash.getProgressMonitor();
    435429        monitor.beginTask(tr("Initializing"));
    436         GuiHelper.runInEDT(new Runnable() {
    437             @Override
    438             public void run() {
    439                 splash.setVisible(Main.pref.getBoolean("draw.splashscreen", true));
    440             }
    441         });
     430        GuiHelper.runInEDT(() -> splash.setVisible(Main.pref.getBoolean("draw.splashscreen", true)));
    442431        Main.setInitStatusListener(new InitStatusListener() {
    443432
    … …  
    474463
    475464        // Wait for splash disappearance (fix #9714)
    476         GuiHelper.runInEDTAndWait(new Runnable() {
    477             @Override
    478             public void run() {
    479                 splash.setVisible(false);
    480                 splash.dispose();
    481                 mainFrame.setVisible(true);
    482             }
     465        GuiHelper.runInEDTAndWait(() -> {
     466            splash.setVisible(false);
     467            splash.dispose();
     468            mainFrame.setVisible(true);
    483469        });
    484470
    … …  
    571557    private static void checkIPv6() {
    572558        if ("auto".equals(Main.pref.get("prefer.ipv6", "auto"))) {
    573              new Thread(new Runnable() { /* this may take some time (DNS, Connect) */
    574                 @Override
    575                 public void run() {
    576                     boolean hasv6 = false;
    577                     boolean wasv6 = Main.pref.getBoolean("validated.ipv6", false);
    578                     try {
    579                         /* Use the check result from last run of the software, as after the test, value
    580                            changes have no effect anymore */
    581                         if (wasv6) {
    582                             Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true");
    583                         }
    584                         for (InetAddress a : InetAddress.getAllByName("josm.openstreetmap.de")) {
    585                             if (a instanceof Inet6Address) {
    586                                 if (a.isReachable(1000)) {
    587                                     /* be sure it REALLY works */
    588                                     Socket s = new Socket();
    589                                     s.connect(new InetSocketAddress(a, 80), 1000);
    590                                     s.close();
    591                                     Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true");
    592                                     if (!wasv6) {
    593                                         Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4 after next restart."));
    594                                     } else {
    595                                         Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4."));
    596                                     }
    597                                     hasv6 = true;
     559            new Thread((Runnable) () -> { /* this may take some time (DNS, Connect) */
     560                boolean hasv6 = false;
     561                boolean wasv6 = Main.pref.getBoolean("validated.ipv6", false);
     562                try {
     563                    /* Use the check result from last run of the software, as after the test, value
     564                       changes have no effect anymore */
     565                    if (wasv6) {
     566                        Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true");
     567                    }
     568                    for (InetAddress a : InetAddress.getAllByName("josm.openstreetmap.de")) {
     569                        if (a instanceof Inet6Address) {
     570                            if (a.isReachable(1000)) {
     571                                /* be sure it REALLY works */
     572                                Socket s = new Socket();
     573                                s.connect(new InetSocketAddress(a, 80), 1000);
     574                                s.close();
     575                                Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true");
     576                                if (!wasv6) {
     577                                    Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4 after next restart."));
     578                                } else {
     579                                    Main.info(tr("Detected useable IPv6 network, prefering IPv6 over IPv4."));
    598580                                }
    599                                 break; /* we're done */
     581                                hasv6 = true;
    600582                            }
    601                         }
    602                     } catch (IOException | SecurityException e) {
    603                         if (Main.isDebugEnabled()) {
    604                             Main.debug("Exception while checking IPv6 connectivity: "+e);
     583                            break; /* we're done */
    605584                        }
    606585                    }
    607                     if (wasv6 && !hasv6) {
    608                         Main.info(tr("Detected no useable IPv6 network, prefering IPv4 over IPv6 after next restart."));
    609                         Main.pref.put("validated.ipv6", hasv6); // be sure it is stored before the restart!
    610                         new RestartAction().actionPerformed(null);
     586                } catch (IOException | SecurityException e) {
     587                    if (Main.isDebugEnabled()) {
     588                        Main.debug("Exception while checking IPv6 connectivity: "+e);
    611589                    }
    612                     Main.pref.put("validated.ipv6", hasv6);
    613                 }
     590                }
     591                if (wasv6 && !hasv6) {
     592                    Main.info(tr("Detected no useable IPv6 network, prefering IPv4 over IPv6 after next restart."));
     593                    Main.pref.put("validated.ipv6", hasv6); // be sure it is stored before the restart!
     594                    new RestartAction().actionPerformed(null);
     595                }
     596                Main.pref.put("validated.ipv6", hasv6);
    614597            }, "IPv6-checker").start();
    615598        }

  • trunk/src/org/openstreetmap/josm/gui/MainFrame.java

    r10432 r10611  
    1414import java.awt.event.WindowAdapter;
    1515import java.awt.event.WindowEvent;
    16 import java.beans.PropertyChangeEvent;
    1716import java.beans.PropertyChangeListener;
    1817import java.util.LinkedList;
    … …  
    2726import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
    2827import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
    29 import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
    30 import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
    3128import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    3229import org.openstreetmap.josm.gui.layer.OsmDataLayer.LayerStateChangeListener;
    … …  
    4037 */
    4138public class MainFrame extends JFrame {
    42     private final transient LayerStateChangeListener updateTitleOnLayerStateChange = new LayerStateChangeListener() {
    43         @Override
    44         public void uploadDiscouragedChanged(OsmDataLayer layer, boolean newValue) {
     39    private final transient LayerStateChangeListener updateTitleOnLayerStateChange = (layer, newValue) -> onLayerChange(layer);
     40
     41    private final transient PropertyChangeListener updateTitleOnSaveChange = evt -> {
     42        if (evt.getPropertyName().equals(OsmDataLayer.REQUIRES_SAVE_TO_DISK_PROP)
     43                || evt.getPropertyName().equals(OsmDataLayer.REQUIRES_UPLOAD_TO_SERVER_PROP)) {
     44            OsmDataLayer layer = (OsmDataLayer) evt.getSource();
    4545            onLayerChange(layer);
    46         }
    47     };
    48 
    49     private final transient PropertyChangeListener updateTitleOnSaveChange = new PropertyChangeListener() {
    50         @Override
    51         public void propertyChange(PropertyChangeEvent evt) {
    52             if (evt.getPropertyName().equals(OsmDataLayer.REQUIRES_SAVE_TO_DISK_PROP)
    53                     || evt.getPropertyName().equals(OsmDataLayer.REQUIRES_UPLOAD_TO_SERVER_PROP)) {
    54                 OsmDataLayer layer = (OsmDataLayer) evt.getSource();
    55                 onLayerChange(layer);
    56             }
    5746        }
    5847    };
    … …  
    10291        addWindowListener(new WindowAdapter() {
    10392            @Override
    104             public void windowClosing(final WindowEvent arg0) {
     93            public void windowClosing(final WindowEvent evt) {
    10594                Main.exitJosm(true, 0);
    10695            }
    … …  
    10998
    11099        // This listener is never removed, since the main frame exists forever.
    111         Main.getLayerManager().addActiveLayerChangeListener(new ActiveLayerChangeListener() {
    112             @Override
    113             public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
    114                 refreshTitle();
    115             }
    116         });
     100        Main.getLayerManager().addActiveLayerChangeListener(e -> refreshTitle());
    117101        Main.getLayerManager().addLayerChangeListener(new ManageLayerListeners(), true);
    118102

  • trunk/src/org/openstreetmap/josm/gui/MainMenu.java

    r10345 r10611  
    113113import org.openstreetmap.josm.actions.audio.AudioSlowerAction;
    114114import org.openstreetmap.josm.actions.search.SearchAction;
    115 import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
    116 import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    117115import org.openstreetmap.josm.gui.dialogs.MenuItemSearchDialog;
    118116import org.openstreetmap.josm.gui.io.RecentlyOpenedFilesMenu;
    … …  
    803801        }
    804802
    805         Main.pref.addPreferenceChangeListener(new PreferenceChangedListener() {
    806             @Override
    807             public void preferenceChanged(PreferenceChangeEvent e) {
    808                 if ("audio.menuinvisible".equals(e.getKey())) {
    809                     showAudioMenu(!Boolean.parseBoolean(e.getNewValue().toString()));
    810                 }
     803        Main.pref.addPreferenceChangeListener(e -> {
     804            if ("audio.menuinvisible".equals(e.getKey())) {
     805                showAudioMenu(!Boolean.parseBoolean(e.getNewValue().toString()));
    811806            }
    812807        });

  • trunk/src/org/openstreetmap/josm/gui/MainPanel.java

    r10508 r10611  
    163163            }
    164164        });
    165         GuiHelper.runInEDTAndWait(new Runnable() {
    166             @Override
    167             public void run() {
    168                 updateContent(!layerManager.getLayers().isEmpty());
    169             }
    170         });
     165        GuiHelper.runInEDTAndWait(() -> updateContent(!layerManager.getLayers().isEmpty()));
    171166    }
    172167}

  • trunk/src/org/openstreetmap/josm/gui/MapFrame.java

    r10604 r10611  
    1313import java.awt.event.ActionEvent;
    1414import java.awt.event.KeyEvent;
    15 import java.awt.event.MouseWheelEvent;
    16 import java.awt.event.MouseWheelListener;
    1715import java.util.ArrayList;
    1816import java.util.Collection;
    … …  
    5351import org.openstreetmap.josm.actions.mapmode.SelectAction;
    5452import org.openstreetmap.josm.actions.mapmode.ZoomAction;
    55 import org.openstreetmap.josm.data.Preferences;
    56 import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
    5753import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    5854import org.openstreetmap.josm.data.ViewportData;
    … …  
    497493        if (Main.pref.getBoolean("sidetoolbar.scrollable", true)) {
    498494            final ScrollViewport svp = new ScrollViewport(sideToolBar, ScrollViewport.VERTICAL_DIRECTION);
    499             svp.addMouseWheelListener(new MouseWheelListener() {
    500                 @Override
    501                 public void mouseWheelMoved(MouseWheelEvent e) {
    502                     svp.scroll(0, e.getUnitsToScroll() * 5);
    503                 }
    504             });
     495            svp.addMouseWheelListener(e -> svp.scroll(0, e.getUnitsToScroll() * 5));
    505496            sideToolBar = svp;
    506497        }
    507498        sideToolBar.setVisible(Main.pref.getBoolean("sidetoolbar.visible", true));
    508         sidetoolbarPreferencesChangedListener = new Preferences.PreferenceChangedListener() {
    509             @Override
    510             public void preferenceChanged(PreferenceChangeEvent e) {
    511                 if ("sidetoolbar.visible".equals(e.getKey())) {
    512                     sideToolBar.setVisible(Main.pref.getBoolean("sidetoolbar.visible"));
    513                 }
     499        sidetoolbarPreferencesChangedListener = e -> {
     500            if ("sidetoolbar.visible".equals(e.getKey())) {
     501                sideToolBar.setVisible(Main.pref.getBoolean("sidetoolbar.visible"));
    514502            }
    515503        };

  • trunk/src/org/openstreetmap/josm/gui/MapStatus.java

    r10448 r10611  
    7878import org.openstreetmap.josm.tools.GBC;
    7979import org.openstreetmap.josm.tools.ImageProvider;
    80 import org.openstreetmap.josm.tools.Predicate;
    8180
    8281/**
    … …  
    294293                    // display them if the middle mouse button is pressed and keep them until the mouse is moved
    295294                    if (middleMouseDown || isAtOldPosition) {
    296                         Collection<OsmPrimitive> osms = mv.getAllNearest(ms.mousePos, new Predicate<OsmPrimitive>() {
    297                             @Override
    298                             public boolean evaluate(OsmPrimitive o) {
    299                                 return isUsablePredicate.evaluate(o) && isSelectablePredicate.evaluate(o);
    300                             }
    301                         });
     295                        Collection<OsmPrimitive> osms = mv.getAllNearest(ms.mousePos,
     296                                o -> isUsablePredicate.evaluate(o) && isSelectablePredicate.evaluate(o));
    302297
    303298                        final JPanel c = new JPanel(new GridBagLayout());
    … …  
    505500            final Popup staticPopup = popup;
    506501            popup = null;
    507             EventQueue.invokeLater(new Runnable() {
    508                @Override
    509                public void run() {
    510                     staticPopup.hide();
    511                 }
    512             });
     502            EventQueue.invokeLater(() -> staticPopup.hide());
    513503        }
    514504
    … …  
    524514                // If an old popup exists, remove it when the new popup has been drawn to keep flickering to a minimum
    525515                final Popup staticOldPopup = this.popup;
    526                 EventQueue.invokeLater(new Runnable() {
    527                     @Override
    528                     public void run() {
    529                         staticPopup.show();
    530                         staticOldPopup.hide();
    531                     }
     516                EventQueue.invokeLater(() -> {
     517                    staticPopup.show();
     518                    staticOldPopup.hide();
    532519                });
    533520            } else {
    534521                // There is no old popup
    535                 EventQueue.invokeLater(new Runnable() {
    536                     @Override
    537                     public void run() {
    538                         staticPopup.show();
    539                     }
    540                 });
     522                EventQueue.invokeLater(() -> staticPopup.show());
    541523            }
    542524            this.popupLabels = lbls;
    … …  
    1010992        statusText.add(entry);
    1011993
    1012         GuiHelper.runInEDT(new Runnable() {
    1013             @Override
    1014             public void run() {
    1015                 helpText.setText(text);
    1016                 helpText.setToolTipText(text);
    1017             }
     994        GuiHelper.runInEDT(() -> {
     995            helpText.setText(text);
     996            helpText.setToolTipText(text);
    1018997        });
    1019998    }

  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r10604 r10611  
    4848import org.openstreetmap.josm.data.imagery.ImageryInfo;
    4949import org.openstreetmap.josm.data.osm.DataSet;
    50 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    5150import org.openstreetmap.josm.data.osm.visitor.paint.PaintColors;
    5251import org.openstreetmap.josm.data.osm.visitor.paint.Rendering;
    … …  
    12671266    }
    12681267
    1269     private final transient SelectionChangedListener repaintSelectionChangedListener = new SelectionChangedListener() {
    1270         @Override
    1271         public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    1272             repaint();
    1273         }
    1274     };
     1268    private final transient SelectionChangedListener repaintSelectionChangedListener = newSelection -> repaint();
    12751269
    12761270    /**

  • trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r10600 r10611  
    5151import org.openstreetmap.josm.data.preferences.IntegerProperty;
    5252import org.openstreetmap.josm.data.projection.Projection;
    53 import org.openstreetmap.josm.data.projection.ProjectionChangeListener;
    5453import org.openstreetmap.josm.data.projection.Projections;
    5554import org.openstreetmap.josm.gui.help.Helpful;
    … …  
    8483    }
    8584
    86     public transient Predicate<OsmPrimitive> isSelectablePredicate = new Predicate<OsmPrimitive>() {
    87         @Override
    88         public boolean evaluate(OsmPrimitive prim) {
    89             if (!prim.isSelectable()) return false;
    90             // if it isn't displayed on screen, you cannot click on it
    91             MapCSSStyleSource.STYLE_SOURCE_LOCK.readLock().lock();
    92             try {
    93                 return !MapPaintStyles.getStyles().get(prim, getDist100Pixel(), NavigatableComponent.this).isEmpty();
    94             } finally {
    95                 MapCSSStyleSource.STYLE_SOURCE_LOCK.readLock().unlock();
    96             }
     85    public transient Predicate<OsmPrimitive> isSelectablePredicate = prim -> {
     86        if (!prim.isSelectable()) return false;
     87        // if it isn't displayed on screen, you cannot click on it
     88        MapCSSStyleSource.STYLE_SOURCE_LOCK.readLock().lock();
     89        try {
     90            return !MapPaintStyles.getStyles().get(prim, getDist100Pixel(), NavigatableComponent.this).isEmpty();
     91        } finally {
     92            MapCSSStyleSource.STYLE_SOURCE_LOCK.readLock().unlock();
    9793        }
    9894    };
    … …  
    143139    // The only events that may move/resize this map view are window movements or changes to the map view size.
    144140    // We can clean this up more by only recalculating the state on repaint.
    145     private final transient HierarchyListener hierarchyListener = new HierarchyListener() {
    146         @Override
    147         public void hierarchyChanged(HierarchyEvent e) {
    148             long interestingFlags = HierarchyEvent.ANCESTOR_MOVED | HierarchyEvent.SHOWING_CHANGED;
    149             if ((e.getChangeFlags() & interestingFlags) != 0) {
    150                 updateLocationState();
    151             }
     141    private final transient HierarchyListener hierarchyListener = e -> {
     142        long interestingFlags = HierarchyEvent.ANCESTOR_MOVED | HierarchyEvent.SHOWING_CHANGED;
     143        if ((e.getChangeFlags() & interestingFlags) != 0) {
     144            updateLocationState();
    152145        }
    153146    };
    … …  
    181174        state = MapViewState.createDefaultState(getWidth(), getHeight());
    182175        // uses weak link.
    183         Main.addProjectionChangeListener(new ProjectionChangeListener() {
    184             @Override
    185             public void projectionChanged(Projection oldValue, Projection newValue) {
    186                 fixProjection();
    187             }
    188         });
     176        Main.addProjectionChangeListener((oldValue, newValue) -> fixProjection());
    189177    }
    190178

  • trunk/src/org/openstreetmap/josm/gui/NotificationManager.java

    r10256 r10611  
    218218                    @Override
    219219                    public void actionPerformed(ActionEvent e) {
    220                         SwingUtilities.invokeLater(new Runnable() {
    221                             @Override
    222                             public void run() {
    223                                 HelpBrowser.setUrlForHelpTopic(note.getHelpTopic());
    224                             }
    225                         });
     220                        SwingUtilities.invokeLater(() -> HelpBrowser.setUrlForHelpTopic(note.getHelpTopic()));
    226221                    }
    227222                });

  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

    r10223 r10611  
    9696                        finish();
    9797                    } else {
    98                         EventQueue.invokeAndWait(new Runnable() {
    99                             @Override
    100                             public void run() {
    101                                 finish();
    102                             }
    103                         });
     98                        EventQueue.invokeAndWait(this::finish);
    10499                    }
    105100                }
    … …  
    114109                    afterFinish();
    115110                } else {
    116                     EventQueue.invokeAndWait(new Runnable() {
    117                         @Override
    118                         public void run() {
    119                             afterFinish();
    120                         }
    121                     });
     111                    EventQueue.invokeAndWait(this::afterFinish);
    122112                }
    123113            }
    … …  
    126116            if (!ignoreException) {
    127117                // Exception has to thrown in EDT to be shown to user
    128                 SwingUtilities.invokeLater(new Runnable() {
    129                     @Override
    130                     public void run() {
    131                         if (e instanceof RuntimeException) {
    132                             BugReportExceptionHandler.handleException(e);
    133                         } else {
    134                             ExceptionDialogUtil.explainException(e);
    135                         }
     118                SwingUtilities.invokeLater(() -> {
     119                    if (e instanceof RuntimeException) {
     120                        BugReportExceptionHandler.handleException(e);
     121                    } else {
     122                        ExceptionDialogUtil.explainException(e);
    136123                    }
    137124                });
    … …  
    150137    public final void run() {
    151138        if (EventQueue.isDispatchThread()) {
    152             new Thread(new Runnable() {
    153                 @Override
    154                 public void run() {
    155                     doRealRun();
    156                 }
    157             }, getClass().getName()).start();
     139            new Thread((Runnable) this::doRealRun, getClass().getName()).start();
    158140        } else {
    159141            doRealRun();

  • trunk/src/org/openstreetmap/josm/gui/ScrollViewport.java

    r10378 r10611  
    66import java.awt.Point;
    77import java.awt.Rectangle;
    8 import java.awt.event.ActionEvent;
    9 import java.awt.event.ActionListener;
    108import java.awt.event.ComponentAdapter;
    119import java.awt.event.ComponentEvent;
    … …  
    7068    private final List<JButton> buttons = new ArrayList<>();
    7169
    72     private final Timer timer = new Timer(100, new ActionListener() {
    73         @Override
    74         public void actionPerformed(ActionEvent arg0) {
    75             ScrollViewport.this.scroll();
    76         }
    77     });
     70    private final Timer timer = new Timer(100, evt -> ScrollViewport.this.scroll());
    7871
    7972    private int scrollDirection = NO_SCROLL;

  • trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

    r10446 r10611  
    172172        eventSource.addMouseMotionListener(this);
    173173        selectionEndedListener.addPropertyChangeListener(this);
    174         eventSource.addPropertyChangeListener("scale", new PropertyChangeListener() {
    175             @Override
    176             public void propertyChange(PropertyChangeEvent evt) {
    177                 abortSelecting();
    178             }
    179         });
     174        eventSource.addPropertyChangeListener("scale", evt -> abortSelecting());
    180175        eventSource.addTemporaryLayer(selectionHintLayer);
    181176    }

  • trunk/src/org/openstreetmap/josm/gui/SideButton.java

    r10489 r10611  
    77import java.awt.Insets;
    88import java.awt.event.ActionListener;
    9 import java.beans.PropertyChangeEvent;
    109import java.beans.PropertyChangeListener;
    1110
    … …  
    8584        // SideButton is constructed get the proper icon size
    8685        if (action != null) {
    87             propertyChangeListener = new PropertyChangeListener() {
    88                 @Override
    89                 public void propertyChange(PropertyChangeEvent evt) {
    90                     if (javax.swing.Action.SMALL_ICON.equals(evt.getPropertyName())) {
    91                         fixIcon(null);
    92                     }
     86            propertyChangeListener = evt -> {
     87                if (javax.swing.Action.SMALL_ICON.equals(evt.getPropertyName())) {
     88                    fixIcon(null);
    9389                }
    9490            };

  • trunk/src/org/openstreetmap/josm/gui/SplashScreen.java

    r10428 r10611  
    119119    @Override
    120120    public void stateChanged(ChangeEvent ignore) {
    121         GuiHelper.runInEDT(new Runnable() {
    122             @Override
    123             public void run() {
    124                 progressRenderer.setTasks(progressMonitor.toString());
    125             }
    126         });
     121        GuiHelper.runInEDT(() -> progressRenderer.setTasks(progressMonitor.toString()));
    127122    }
    128123

  • trunk/src/org/openstreetmap/josm/gui/bbox/SlippyMapBBoxChooser.java

    r10600 r10611  
    9696    private static CopyOnWriteArrayList<TileSourceProvider> providers = new CopyOnWriteArrayList<>();
    9797    static {
    98         addTileSourceProvider(new TileSourceProvider() {
    99             @Override
    100             public List<TileSource> getTileSources() {
    101                 return Arrays.<TileSource>asList(
    102                         new OsmTileSource.Mapnik(),
    103                         new OsmTileSource.CycleMap());
    104             }
    105         });
     98        addTileSourceProvider(() -> Arrays.<TileSource>asList(
     99                new OsmTileSource.Mapnik(),
     100                new OsmTileSource.CycleMap()));
    106101        addTileSourceProvider(new TMSTileSourceProvider());
    107102    }

  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/ListMerger.java

    r10454 r10611  
    806806        public void adapt(final JToggleButton btn) {
    807807            btn.addItemListener(this);
    808             addPropertyChangeListener(
    809                     new PropertyChangeListener() {
    810                         @Override
    811                         public void propertyChange(PropertyChangeEvent evt) {
    812                             if (evt.getPropertyName().equals(PROP_SELECTED)) {
    813                                 btn.setSelected((Boolean) evt.getNewValue());
    814                             }
    815                         }
     808            addPropertyChangeListener(evt -> {
     809                    if (evt.getPropertyName().equals(PROP_SELECTED)) {
     810                        btn.setSelected((Boolean) evt.getNewValue());
    816811                    }
    817             );
     812                });
    818813        }
    819814

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/CombinePrimitiveResolverDialog.java

    r10527 r10611  
    9898    public static synchronized CombinePrimitiveResolverDialog getInstance() {
    9999        if (instance == null) {
    100             GuiHelper.runInEDTAndWait(new Runnable() {
    101                 @Override public void run() {
    102                     instance = new CombinePrimitiveResolverDialog(Main.parent);
    103                 }
    104             });
     100            GuiHelper.runInEDTAndWait(() -> instance = new CombinePrimitiveResolverDialog(Main.parent));
    105101        }
    106102        return instance;
    … …  
    136132    public void setTargetPrimitive(final OsmPrimitive primitive) {
    137133        this.targetPrimitive = primitive;
    138         GuiHelper.runInEDTAndWait(new Runnable() {
    139             @Override public void run() {
    140                 updateTitle();
    141                 if (primitive instanceof Way) {
    142                     pnlRelationMemberConflictResolver.initForWayCombining();
    143                 } else if (primitive instanceof Node) {
    144                     pnlRelationMemberConflictResolver.initForNodeMerging();
    145                 }
     134        GuiHelper.runInEDTAndWait(() -> {
     135            updateTitle();
     136            if (primitive instanceof Way) {
     137                pnlRelationMemberConflictResolver.initForWayCombining();
     138            } else if (primitive instanceof Node) {
     139                pnlRelationMemberConflictResolver.initForNodeMerging();
    146140            }
    147141        });
    … …  
    576570            final TagCollection normalizedTags) throws UserCancelException {
    577571        String conflicts = Utils.joinAsHtmlUnorderedList(Utils.transform(normalizedTags.getKeysWithMultipleValues(),
    578                 new Function<String, String>() {
    579             @Override
    580             public String apply(String key) {
    581                 return tr("{0} ({1})", key, Utils.join(tr(", "), Utils.transform(normalizedTags.getValues(key),
    582                         new Function<String, String>() {
    583                     @Override
    584                     public String apply(String x) {
    585                         return x == null || x.isEmpty() ? tr("<i>missing</i>") : x;
    586                     }
    587                 })));
    588             }
    589         }));
     572                (Function<String, String>) key -> tr("{0} ({1})", key, Utils.join(tr(", "), Utils.transform(normalizedTags.getValues(key),
     573                        (Function<String, String>) x -> x == null || x.isEmpty() ? tr("<i>missing</i>") : x)))));
    590574        String msg = /* for correct i18n of plural forms - see #9110 */ trn("You are about to combine {0} objects, "
    591575                + "but the following tags are used conflictingly:<br/>{1}"

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MultiValueCellEditor.java

    r9078 r10611  
    99import java.awt.event.FocusEvent;
    1010import java.awt.event.ItemEvent;
    11 import java.awt.event.ItemListener;
    1211import java.awt.event.KeyEvent;
    1312import java.util.concurrent.CopyOnWriteArrayList;
    … …  
    120119                }
    121120        );
    122         editor.addItemListener(
    123                 new ItemListener() {
    124                     @Override
    125                     public void itemStateChanged(ItemEvent e) {
    126                         if (e.getStateChange() == ItemEvent.SELECTED)
    127                             fireEditingStopped();
    128                     }
    129                 }
    130         );
     121        editor.addItemListener(e -> {
     122            if (e.getStateChange() == ItemEvent.SELECTED)
     123                fireEditingStopped();
     124        });
    131125        editor.setRenderer(new EditorCellRenderer());
    132126        listeners = new CopyOnWriteArrayList<>();

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/RelationMemberConflictDecisionEditor.java

    r9143 r10611  
    33
    44import java.awt.Component;
    5 import java.awt.event.ActionEvent;
    6 import java.awt.event.ActionListener;
    75import java.util.EventObject;
    86
    … …  
    3836    @Override
    3937    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
    40         addActionListener(new ActionListener() {
    41             @Override
    42             public void actionPerformed(ActionEvent e) {
    43                 stopCellEditing();
    44             }
    45         });
     38        addActionListener(e -> stopCellEditing());
    4639        setSelectedItem(value);
    4740        this.originalValue = (RelationMemberConflictDecisionType) value;

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/RelationMemberConflictResolverColumnModel.java

    r10308 r10611  
    2929    };
    3030
    31     private final transient TableCellRenderer tableRenderer = new TableCellRenderer() {
    32         @Override
    33         public Component getTableCellRendererComponent(JTable table, Object value,
    34                 boolean isSelected, boolean hasFocus, int row, int column) {
    35             return setColors(defaultTableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column),
    36                     table, isSelected, row);
    37         }
    38     };
     31    private final transient TableCellRenderer tableRenderer = (table, value, isSelected, hasFocus, row, column)
     32            -> setColors(defaultTableCellRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column),
     33            table, isSelected, row);
    3934
    4035    private static Component setColors(Component comp, JTable table, boolean isSelected, int row) {

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/RelationMemberConflictResolverModel.java

    r10593 r10611  
    2525import org.openstreetmap.josm.data.osm.RelationToChildReference;
    2626import org.openstreetmap.josm.gui.util.GuiHelper;
    27 import org.openstreetmap.josm.tools.Predicate;
    2827import org.openstreetmap.josm.tools.Utils;
    2928
    … …  
    235234                    iterators.add(i.iterator());
    236235                }
    237                 while (Utils.forAll(iterators, new Predicate<Iterator<RelationMemberConflictDecision>>() {
    238                     @Override
    239                     public boolean evaluate(Iterator<RelationMemberConflictDecision> it) {
    240                         return it.hasNext();
    241                     }
    242                 })) {
     236                while (Utils.forAll(iterators, it -> it.hasNext())) {
    243237                    final List<RelationMemberConflictDecision> decisions = new ArrayList<>();
    244238                    final Collection<String> roles = new HashSet<>();
    … …  
    310304    public void refresh() {
    311305        updateNumConflicts();
    312         GuiHelper.runInEDTAndWait(new Runnable() {
    313             @Override public void run() {
    314                 fireTableDataChanged();
    315             }
    316         });
     306        GuiHelper.runInEDTAndWait(this::fireTableDataChanged);
    317307    }
    318308

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagConflictResolver.java

    r10179 r10611  
    1313import javax.swing.JPanel;
    1414import javax.swing.JScrollPane;
    15 import javax.swing.event.ChangeEvent;
    16 import javax.swing.event.ChangeListener;
    1715
    1816import org.openstreetmap.josm.Main;
    … …  
    5654        pnl.add(cbShowTagsWithConflictsOnly, gc);
    5755        pnl.add(cbShowTagsWithMultiValuesOnly, gc);
    58         cbShowTagsWithConflictsOnly.addChangeListener(
    59                 new ChangeListener() {
    60                     @Override
    61                     public void stateChanged(ChangeEvent e) {
    62                         model.setShowTagsWithConflictsOnly(cbShowTagsWithConflictsOnly.isSelected());
    63                         cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
    64                     }
    65                 }
    66         );
     56        cbShowTagsWithConflictsOnly.addChangeListener(e -> {
     57                model.setShowTagsWithConflictsOnly(cbShowTagsWithConflictsOnly.isSelected());
     58                cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
     59        });
    6760        cbShowTagsWithConflictsOnly.setSelected(
    6861                Main.pref.getBoolean(getClass().getName() + ".showTagsWithConflictsOnly", false)
    6962        );
    7063        cbShowTagsWithMultiValuesOnly.addChangeListener(
    71                 new ChangeListener() {
    72                     @Override
    73                     public void stateChanged(ChangeEvent e) {
    74                         model.setShowTagsWithMultiValuesOnly(cbShowTagsWithMultiValuesOnly.isSelected());
    75                     }
    76                 }
     64                e -> model.setShowTagsWithMultiValuesOnly(cbShowTagsWithMultiValuesOnly.isSelected())
    7765        );
    7866        cbShowTagsWithMultiValuesOnly.setSelected(

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagConflictResolverModel.java

    r10593 r10611  
    66import java.util.ArrayList;
    77import java.util.Collections;
    8 import java.util.Comparator;
    98import java.util.HashMap;
    109import java.util.HashSet;
    … …  
    6867        Collections.sort(
    6968                displayedKeys,
    70                 new Comparator<String>() {
    71                     @Override
    72                     public int compare(String key1, String key2) {
    73                         if (decisions.get(key1).isDecided() && !decisions.get(key2).isDecided())
    74                             return 1;
    75                         else if (!decisions.get(key1).isDecided() && decisions.get(key2).isDecided())
    76                             return -1;
    77                         return key1.compareTo(key2);
    78                     }
     69                (key1, key2) -> {
     70                    if (decisions.get(key1).isDecided() && !decisions.get(key2).isDecided())
     71                        return 1;
     72                    else if (!decisions.get(key1).isDecided() && decisions.get(key2).isDecided())
     73                        return -1;
     74                    return key1.compareTo(key2);
    7975                }
    8076        );
    … …  
    115111        refreshNumConflicts();
    116112        sort();
    117         GuiHelper.runInEDTAndWait(new Runnable() {
    118             @Override public void run() {
    119                 fireTableDataChanged();
    120             }
    121         });
     113        GuiHelper.runInEDTAndWait(this::fireTableDataChanged);
    122114    }
    123115
    … …  
    184176            }
    185177        }
    186         GuiHelper.runInEDTAndWait(new Runnable() {
    187             @Override public void run() {
    188                 fireTableDataChanged();
    189             }
    190         });
     178        GuiHelper.runInEDTAndWait(this::fireTableDataChanged);
    191179        refreshNumConflicts();
    192180    }

  • trunk/src/org/openstreetmap/josm/gui/datatransfer/ClipboardUtils.java

    r10604 r10611  
    1212import java.awt.datatransfer.UnsupportedFlavorException;
    1313import java.io.IOException;
    14 import java.util.concurrent.Callable;
    1514
    1615import org.openstreetmap.josm.Main;
    … …  
    139138     */
    140139    public static boolean copy(final Transferable transferable) {
    141         return GuiHelper.runInEDTAndWaitAndReturn(new Callable<Boolean>() {
    142             @Override
    143             public Boolean call() throws Exception {
    144                 try {
    145                     getClipboard().setContents(transferable, new DoNothingClipboardOwner());
    146                     return true;
    147                 } catch (IllegalStateException ex) {
    148                     Main.error(ex);
    149                     return false;
    150                 }
     140        return GuiHelper.runInEDTAndWaitAndReturn(() -> {
     141            try {
     142                getClipboard().setContents(transferable, new DoNothingClipboardOwner());
     143                return true;
     144            } catch (IllegalStateException ex) {
     145                Main.error(ex);
     146                return false;
    151147            }
    152148        });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r10453 r10611  
    522522            }
    523523
    524             Runnable r = new Runnable() {
    525                 @Override
    526                 public void run() {
    527                     // first, wait for the download task to finish, if a download task was launched
    528                     if (future != null) {
    529                         try {
    530                             future.get();
    531                         } catch (InterruptedException e) {
    532                             Main.warn("InterruptedException in "+getClass().getSimpleName()+" while downloading changeset header");
    533                         } catch (ExecutionException e) {
    534                             Main.error(e);
    535                             BugReportExceptionHandler.handleException(e.getCause());
    536                             return;
    537                         }
     524            Runnable r = () -> {
     525                // first, wait for the download task to finish, if a download task was launched
     526                if (future != null) {
     527                    try {
     528                        future.get();
     529                    } catch (InterruptedException e1) {
     530                        Main.warn(e1, "InterruptedException in ChangesetDialog while downloading changeset header");
     531                    } catch (ExecutionException e2) {
     532                        Main.error(e2);
     533                        BugReportExceptionHandler.handleException(e2.getCause());
     534                        return;
    538535                    }
    539                     if (task != null) {
    540                         if (task.isCanceled())
    541                             // don't launch the changeset manager if the download task was canceled
    542                             return;
    543                         if (task.isFailed()) {
    544                             toDownload.clear();
    545                         }
     536                }
     537                if (task != null) {
     538                    if (task.isCanceled())
     539                        // don't launch the changeset manager if the download task was canceled
     540                        return;
     541                    if (task.isFailed()) {
     542                        toDownload.clear();
    546543                    }
    547                     // launch the task
    548                     GuiHelper.runInEDT(new Runnable() {
    549                         @Override
    550                         public void run() {
    551                             launchChangesetManager(sel);
    552                         }
    553                     });
    554544                }
     545                // launch the task
     546                GuiHelper.runInEDT(() -> launchChangesetManager(sel));
    555547            };
    556548            Main.worker.submit(r);

  • trunk/src/org/openstreetmap/josm/gui/dialogs/CommandStackDialog.java

    r10600 r10611  
    4949import org.openstreetmap.josm.tools.ImageProvider;
    5050import org.openstreetmap.josm.tools.InputMapUtils;
    51 import org.openstreetmap.josm.tools.Predicate;
    5251import org.openstreetmap.josm.tools.Shortcut;
    5352
    … …  
    197196        addShowNotifyListener(updater);
    198197
    199         tree.addTreeSelectionListener(new TreeSelectionListener() {
    200             @Override
    201             public void valueChanged(TreeSelectionEvent e) {
    202                 updater.updateEnabledState();
    203             }
    204         });
     198        tree.addTreeSelectionListener(e -> updater.updateEnabledState());
    205199
    206200        tree.getModel().addTreeModelListener(new TreeModelListener() {
    … …  
    342336        return new FilteredCollection<>(
    343337                c.getParticipatingPrimitives(),
    344                 new Predicate<OsmPrimitive>() {
    345                     @Override
    346                     public boolean evaluate(OsmPrimitive o) {
    347                         OsmPrimitive p = currentLayer.data.getPrimitiveById(o);
    348                         return p != null && p.isUsable();
    349                     }
     338                o -> {
     339                    OsmPrimitive p = currentLayer.data.getPrimitiveById(o);
     340                    return p != null && p.isUsable();
    350341                }
    351342        );

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r10446 r10611  
    123123        lstConflicts.setCellRenderer(new OsmPrimitivRenderer());
    124124        lstConflicts.addMouseListener(new MouseEventHandler());
    125         addListSelectionListener(new ListSelectionListener() {
    126             @Override
    127             public void valueChanged(ListSelectionEvent e) {
    128                 Main.map.mapView.repaint();
    129             }
    130         });
     125        addListSelectionListener(e -> Main.map.mapView.repaint());
    131126
    132127        SideButton btnResolve = new SideButton(actResolve);
    … …  
    236231        OsmDataLayer editLayer = Main.getLayerManager().getEditLayer();
    237232        conflicts = editLayer == null ? new ConflictCollection() : editLayer.getConflicts();
    238         GuiHelper.runInEDT(new Runnable() {
    239             @Override
    240             public void run() {
    241                 model.fireContentChanged();
    242                 updateTitle();
    243             }
     233        GuiHelper.runInEDT(() -> {
     234            model.fireContentChanged();
     235            updateTitle();
    244236        });
    245237    }
    … …  
    597589                    )
    598590            };
    599             GuiHelper.runInEDT(new Runnable() {
    600                 @Override
    601                 public void run() {
    602                     HelpAwareOptionPane.showOptionDialog(
    603                             Main.parent,
    604                             sb.toString(),
    605                             tr("Conflicts detected"),
    606                             JOptionPane.WARNING_MESSAGE,
    607                             null, /* no icon */
    608                             options,
    609                             options[0],
    610                             ht("/Concepts/Conflict#WarningAboutDetectedConflicts")
    611                     );
    612                     unfurlDialog();
    613                     Main.map.repaint();
    614                 }
     591            GuiHelper.runInEDT(() -> {
     592                HelpAwareOptionPane.showOptionDialog(
     593                        Main.parent,
     594                        sb.toString(),
     595                        tr("Conflicts detected"),
     596                        JOptionPane.WARNING_MESSAGE,
     597                        null, /* no icon */
     598                        options,
     599                        options[0],
     600                        ht("/Concepts/Conflict#WarningAboutDetectedConflicts")
     601                );
     602                unfurlDialog();
     603                Main.map.repaint();
    615604            });
    616605        }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterDialog.java

    r10378 r10611  
    276276
    277277    public void updateDialogHeader() {
    278         SwingUtilities.invokeLater(new Runnable() {
    279             @Override
    280             public void run() {
    281                 setTitle(tr("Filter Hidden:{0} Disabled:{1}", filterModel.disabledAndHiddenCount, filterModel.disabledCount));
    282             }
    283         });
     278        SwingUtilities.invokeLater(() -> setTitle(
     279                tr("Filter Hidden:{0} Disabled:{1}", filterModel.disabledAndHiddenCount, filterModel.disabledCount)));
    284280    }
    285281

  • trunk/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDialog.java

    r10446 r10611  
    2121import javax.swing.JTabbedPane;
    2222import javax.swing.SingleSelectionModel;
    23 import javax.swing.event.ChangeEvent;
    24 import javax.swing.event.ChangeListener;
    2523
    2624import org.openstreetmap.josm.Main;
    … …  
    7876        final JPanel pMapPaint = new JPanel();
    7977        tabs.addTab(tr("map style"), pMapPaint);
    80         tabs.getModel().addChangeListener(new ChangeListener() {
    81 
    82             @Override
    83             public void stateChanged(ChangeEvent e) {
    84                 if (!mappaintTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 1) {
    85                     mappaintTabLoaded = true;
    86                     genericMonospacePanel(pMapPaint, buildMapPaintText());
    87                 }
     78        tabs.getModel().addChangeListener(e -> {
     79            if (!mappaintTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 1) {
     80                mappaintTabLoaded = true;
     81                genericMonospacePanel(pMapPaint, buildMapPaintText());
    8882            }
    8983        });
    … …  
    9185        final JPanel pEditCounts = new JPanel();
    9286        tabs.addTab(tr("edit counts"), pEditCounts);
    93         tabs.getModel().addChangeListener(new ChangeListener() {
    94 
    95             @Override
    96             public void stateChanged(ChangeEvent e) {
    97                 if (!editcountTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 2) {
    98                     editcountTabLoaded = true;
    99                     genericMonospacePanel(pEditCounts, buildListOfEditorsText(primitives));
    100                 }
     87        tabs.getModel().addChangeListener(e -> {
     88            if (!editcountTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 2) {
     89                editcountTabLoaded = true;
     90                genericMonospacePanel(pEditCounts, buildListOfEditorsText(primitives));
    10191            }
    10292        });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/LatLonDialog.java

    r10300 r10611  
    2222import javax.swing.JTabbedPane;
    2323import javax.swing.UIManager;
    24 import javax.swing.event.ChangeEvent;
    25 import javax.swing.event.ChangeListener;
    2624import javax.swing.event.DocumentEvent;
    2725import javax.swing.event.DocumentListener;
    … …  
    167165        tabs.addTab(tr("Lat/Lon"), buildLatLon());
    168166        tabs.addTab(tr("East/North"), buildEastNorth());
    169         tabs.getModel().addChangeListener(new ChangeListener() {
    170             @Override
    171             public void stateChanged(ChangeEvent e) {
    172                 switch (tabs.getModel().getSelectedIndex()) {
    173                     case 0: parseLatLonUserInput(); break;
    174                     case 1: parseEastNorthUserInput(); break;
    175                     default: throw new AssertionError();
    176                 }
     167        tabs.getModel().addChangeListener(e -> {
     168            switch (tabs.getModel().getSelectedIndex()) {
     169                case 0: parseLatLonUserInput(); break;
     170                case 1: parseEastNorthUserInput(); break;
     171                default: throw new AssertionError();
    177172            }
    178173        });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r10605 r10611  
    3737import javax.swing.event.ListDataEvent;
    3838import javax.swing.event.ListSelectionEvent;
    39 import javax.swing.event.ListSelectionListener;
    40 import javax.swing.event.TableModelEvent;
    41 import javax.swing.event.TableModelListener;
    4239import javax.swing.table.AbstractTableModel;
    4340import javax.swing.table.DefaultTableCellRenderer;
    … …  
    362359     */
    363360    protected void adaptTo(final IEnabledStateUpdating listener, ListSelectionModel listSelectionModel) {
    364         listSelectionModel.addListSelectionListener(
    365                 new ListSelectionListener() {
    366                     @Override
    367                     public void valueChanged(ListSelectionEvent e) {
    368                         listener.updateEnabledState();
    369                     }
    370                 }
    371                 );
     361        listSelectionModel.addListSelectionListener(e -> listener.updateEnabledState());
    372362    }
    373363
    … …  
    381371     */
    382372    protected void adaptTo(final IEnabledStateUpdating listener, LayerListModel listModel) {
    383         listModel.addTableModelListener(
    384                 new TableModelListener() {
    385                     @Override
    386                     public void tableChanged(TableModelEvent e) {
    387                         listener.updateEnabledState();
    388                     }
    389                 }
    390                 );
     373        listModel.addTableModelListener(e -> listener.updateEnabledState());
    391374    }
    392375

  • trunk/src/org/openstreetmap/josm/gui/dialogs/MapPaintDialog.java

    r10465 r10611  
    1313import java.awt.Rectangle;
    1414import java.awt.event.ActionEvent;
    15 import java.awt.event.ActionListener;
    1615import java.awt.event.KeyEvent;
    1716import java.awt.event.MouseEvent;
    … …  
    5049import javax.swing.UIManager;
    5150import javax.swing.border.EmptyBorder;
    52 import javax.swing.event.ChangeEvent;
    53 import javax.swing.event.ChangeListener;
    5451import javax.swing.event.ListSelectionEvent;
    5552import javax.swing.event.ListSelectionListener;
    … …  
    139136            }
    140137        });
    141         cbWireframe.addActionListener(new ActionListener() {
    142             @Override
    143             public void actionPerformed(ActionEvent e) {
    144                 Main.main.menu.wireFrameToggleAction.actionPerformed(null);
    145             }
    146         });
     138        cbWireframe.addActionListener(e -> Main.main.menu.wireFrameToggleAction.actionPerformed(null));
    147139        cbWireframe.setBorder(new EmptyBorder(new Insets(1, 1, 1, 1)));
    148140
    … …  
    441433            final int[] rows = tblStyles.getSelectedRows();
    442434            MapPaintStyles.reloadStyles(rows);
    443             Main.worker.submit(new Runnable() {
    444                 @Override
    445                 public void run() {
    446                     SwingUtilities.invokeLater(new Runnable() {
    447                         @Override
    448                         public void run() {
    449                             selectionModel.clearSelection();
    450                             for (int r: rows) {
    451                                 selectionModel.addSelectionInterval(r, r);
    452                             }
    453                         }
    454                     });
     435            Main.worker.submit(() -> SwingUtilities.invokeLater(() -> {
     436                selectionModel.clearSelection();
     437                for (int r: rows) {
     438                    selectionModel.addSelectionInterval(r, r);
    455439                }
    456             });
     440            }));
    457441        }
    458442    }
    … …  
    531515            @Override
    532516            protected void finish() {
    533                 SwingUtilities.invokeLater(new Runnable() {
    534                     @Override
    535                     public void run() {
    536                         if (!error && !canceled) {
    537                             SourceEntry se = new SourceEntry(s);
    538                             se.url = file.getPath();
    539                             MapPaintStyles.addStyle(se);
    540                             tblStyles.getSelectionModel().setSelectionInterval(model.getRowCount() - 1, model.getRowCount() - 1);
    541                             model.ensureSelectedIsVisible();
    542                         }
     517                SwingUtilities.invokeLater(() -> {
     518                    if (!error && !canceled) {
     519                        SourceEntry se = new SourceEntry(s);
     520                        se.url = file.getPath();
     521                        MapPaintStyles.addStyle(se);
     522                        tblStyles.getSelectionModel().setSelectionInterval(model.getRowCount() - 1, model.getRowCount() - 1);
     523                        model.ensureSelectedIsVisible();
    543524                    }
    544525                });
    … …  
    594575            tabs.setTabComponentAt(3, lblSource);
    595576
    596             tabs.getModel().addChangeListener(new ChangeListener() {
    597                 @Override
    598                 public void stateChanged(ChangeEvent e) {
    599                     if (!errorsTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 1) {
    600                         errorsTabLoaded = true;
    601                         buildErrorsOrWarningPanel(s.getErrors(), pErrors);
    602                     }
    603                     if (!warningsTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 2) {
    604                         warningsTabLoaded = true;
    605                         buildErrorsOrWarningPanel(s.getWarnings(), pWarnings);
    606                     }
    607                     if (!sourceTabLoaded && ((SingleSelectionModel) e.getSource()).getSelectedIndex() == 3) {
    608                         sourceTabLoaded = true;
    609                         buildSourcePanel(s, pSource);
    610                     }
     577            tabs.getModel().addChangeListener(e1 -> {
     578                if (!errorsTabLoaded && ((SingleSelectionModel) e1.getSource()).getSelectedIndex() == 1) {
     579                    errorsTabLoaded = true;
     580                    buildErrorsOrWarningPanel(s.getErrors(), pErrors);
     581                }
     582                if (!warningsTabLoaded && ((SingleSelectionModel) e1.getSource()).getSelectedIndex() == 2) {
     583                    warningsTabLoaded = true;
     584                    buildErrorsOrWarningPanel(s.getWarnings(), pWarnings);
     585                }
     586                if (!sourceTabLoaded && ((SingleSelectionModel) e1.getSource()).getSelectedIndex() == 3) {
     587                    sourceTabLoaded = true;
     588                    buildSourcePanel(s, pSource);
    611589                }
    612590            });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/MenuItemSearchDialog.java

    r9410 r10611  
    77import java.awt.Dimension;
    88import java.awt.event.ActionEvent;
    9 import java.awt.event.ActionListener;
    109import java.awt.event.KeyEvent;
    1110
    … …  
    3130        super(Main.parent, tr("Search menu items"), new String[]{tr("Select"), tr("Cancel")});
    3231        this.selector = new Selector(menu);
    33         this.selector.setDblClickListener(new ActionListener() {
    34             @Override
    35             public void actionPerformed(ActionEvent e) {
    36                 buttonAction(0, null);
    37             }
    38         });
     32        this.selector.setDblClickListener(e -> buttonAction(0, null));
    3933        setContent(selector, false);
    4034        setPreferredSize(new Dimension(600, 300));

  • trunk/src/org/openstreetmap/josm/gui/dialogs/NotesDialog.java

    r10428 r10611  
    2727import javax.swing.ListSelectionModel;
    2828import javax.swing.SwingUtilities;
    29 import javax.swing.event.ListSelectionEvent;
    30 import javax.swing.event.ListSelectionListener;
    3129
    3230import org.openstreetmap.josm.Main;
    … …  
    8785        displayList.setCellRenderer(new NoteRenderer());
    8886        displayList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    89         displayList.addListSelectionListener(new ListSelectionListener() {
    90             @Override
    91             public void valueChanged(ListSelectionEvent e) {
    92                 if (noteData != null) { //happens when layer is deleted while note selected
    93                     noteData.setSelectedNote(displayList.getSelectedValue());
    94                 }
    95                 updateButtonStates();
    96             }
     87        displayList.addListSelectionListener(e -> {
     88            if (noteData != null) { //happens when layer is deleted while note selected
     89                noteData.setSelectedNote(displayList.getSelectedValue());
     90            }
     91            updateButtonStates();
    9792        });
    9893        displayList.addMouseListener(new MouseAdapter() {

  • trunk/src/org/openstreetmap/josm/gui/dialogs/OsmIdSelectionDialog.java

    r10604 r10611  
    77import java.awt.Component;
    88import java.awt.Dimension;
    9 import java.awt.event.ItemEvent;
    10 import java.awt.event.ItemListener;
    119import java.awt.event.KeyEvent;
    1210import java.awt.event.WindowEvent;
    … …  
    4139import org.openstreetmap.josm.gui.widgets.OsmPrimitiveTypesComboBox;
    4240import org.openstreetmap.josm.tools.Utils;
     41import org.openstreetmap.josm.tools.Utils.Function;
    4342
    4443/**
    … …  
    105104        help.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
    106105
    107         cbType.addItemListener(new ItemListener() {
    108             @Override
    109             public void itemStateChanged(ItemEvent e) {
    110                 tfId.setType(cbType.getType());
    111                 tfId.performValidation();
    112             }
     106        cbType.addItemListener(e -> {
     107            tfId.setType(cbType.getType());
     108            tfId.performValidation();
    113109        });
    114110
    … …  
    208204        final List<SimplePrimitiveId> ids = SimplePrimitiveId.fuzzyParse(buf);
    209205        if (!ids.isEmpty()) {
    210             final String parsedText = Utils.join(", ", Utils.transform(ids, new Utils.Function<SimplePrimitiveId, String>() {
    211                 @Override
    212                 public String apply(SimplePrimitiveId x) {
    213                     return x.getType().getAPIName().charAt(0) + String.valueOf(x.getUniqueId());
    214                 }
    215             }));
     206            final String parsedText = Utils.join(", ", Utils.transform(ids,
     207                    (Function<SimplePrimitiveId, String>) x -> x.getType().getAPIName().charAt(0) + String.valueOf(x.getUniqueId())));
    216208            tfId.tryToPasteFrom(parsedText);
    217             final Set<OsmPrimitiveType> types = EnumSet.copyOf(Utils.transform(ids, new Utils.Function<SimplePrimitiveId, OsmPrimitiveType>() {
    218                 @Override
    219                 public OsmPrimitiveType apply(SimplePrimitiveId x) {
    220                     return x.getType();
    221                 }
    222             }));
     209            final Set<OsmPrimitiveType> types = EnumSet.copyOf(Utils.transform(ids,
     210                    (Function<SimplePrimitiveId, OsmPrimitiveType>) x -> x.getType()));
    223211            if (types.size() == 1) {
    224212                // select corresponding type

  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r10453 r10611  
    99import java.awt.event.KeyEvent;
    1010import java.awt.event.MouseEvent;
    11 import java.beans.PropertyChangeEvent;
    12 import java.beans.PropertyChangeListener;
    1311import java.util.ArrayList;
    1412import java.util.Arrays;
    … …  
    3129import javax.swing.KeyStroke;
    3230import javax.swing.ListSelectionModel;
    33 import javax.swing.event.ListSelectionEvent;
    34 import javax.swing.event.ListSelectionListener;
    3531
    3632import org.openstreetmap.josm.Main;
    … …  
    8379import org.openstreetmap.josm.tools.ImageProvider;
    8480import org.openstreetmap.josm.tools.InputMapUtils;
    85 import org.openstreetmap.josm.tools.Predicate;
    8681import org.openstreetmap.josm.tools.Shortcut;
    8782import org.openstreetmap.josm.tools.Utils;
    … …  
    162157        filter = setupFilter();
    163158
    164         displaylist.addListSelectionListener(new ListSelectionListener() {
    165             @Override
    166             public void valueChanged(ListSelectionEvent e) {
    167                 updateActionsRelationLists();
    168             }
    169         });
     159        displaylist.addListSelectionListener(e -> updateActionsRelationLists());
    170160
    171161        // Setup popup menu handler
    … …  
    309299        f.setToolTipText(tr("Relation list filter"));
    310300        final CompileSearchTextDecorator decorator = CompileSearchTextDecorator.decorate(f);
    311         f.addPropertyChangeListener("filter", new PropertyChangeListener() {
    312             @Override
    313             public void propertyChange(PropertyChangeEvent evt) {
    314                 model.setFilter(decorator.getMatch());
    315             }
    316         });
     301        f.addPropertyChangeListener("filter", evt -> model.setFilter(decorator.getMatch()));
    317302        return f;
    318303    }
    … …  
    506491        private void updateFilteredRelations() {
    507492            if (filter != null) {
    508                 filteredRelations = new ArrayList<>(Utils.filter(relations, new Predicate<Relation>() {
    509                     @Override
    510                     public boolean evaluate(Relation r) {
    511                         return filter.match(r);
    512                     }
    513                 }));
     493                filteredRelations = new ArrayList<>(Utils.filter(relations, filter::match));
    514494            } else if (filteredRelations != null) {
    515495                filteredRelations = null;

  • trunk/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r10604 r10611  
    125125        // the select action
    126126        final SideButton selectButton = new SideButton(actSelect);
    127         selectButton.createArrow(new ActionListener() {
    128             @Override
    129             public void actionPerformed(ActionEvent e) {
    130                 SelectionHistoryPopup.launch(selectButton, model.getSelectionHistory());
    131             }
    132         });
     127        selectButton.createArrow(e -> SelectionHistoryPopup.launch(selectButton, model.getSelectionHistory()));
    133128
    134129        // the search button
    135130        final SideButton searchButton = new SideButton(actSearch);
    136         searchButton.createArrow(new ActionListener() {
    137             @Override
    138             public void actionPerformed(ActionEvent e) {
    139                 SearchPopupMenu.launch(searchButton);
    140             }
    141         });
     131        searchButton.createArrow(e -> SearchPopupMenu.launch(searchButton));
    142132
    143133        createLayout(lstPrimitives, true, Arrays.asList(new SideButton[] {
    … …  
    164154        popupMenuHandler = setupPopupMenuHandler();
    165155
    166         lstPrimitives.addListSelectionListener(new ListSelectionListener() {
    167             @Override
    168             public void valueChanged(ListSelectionEvent e) {
    169                 actZoomToListSelection.valueChanged(e);
    170                 popupMenuHandler.setPrimitives(model.getSelected());
    171             }
     156        lstPrimitives.addListSelectionListener(e -> {
     157            actZoomToListSelection.valueChanged(e);
     158            popupMenuHandler.setPrimitives(model.getSelected());
    172159        });
    173160

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r10491 r10611  
    1818import java.awt.event.AWTEventListener;
    1919import java.awt.event.ActionEvent;
    20 import java.awt.event.ActionListener;
    2120import java.awt.event.ComponentAdapter;
    2221import java.awt.event.ComponentEvent;
    … …  
    513512        private DialogPopupMenu popupMenu;
    514513
     514        @SuppressWarnings("unchecked")
    515515        public TitleBar(String toggleDialogName, String iconName) {
    516516            setLayout(new GridBagLayout());
    … …  
    544544            buttonsHide.setToolTipText(tr("Toggle dynamic buttons"));
    545545            buttonsHide.setBorder(BorderFactory.createEmptyBorder());
    546             buttonsHide.addActionListener(
    547                     new ActionListener() {
    548                         @Override
    549                         public void actionPerformed(ActionEvent e) {
    550                             JRadioButtonMenuItem item = (buttonHiding == ButtonHidingType.DYNAMIC) ? alwaysShown : dynamic;
    551                             item.setSelected(true);
    552                             item.getAction().actionPerformed(null);
    553                         }
    554                     }
    555                     );
     546            buttonsHide.addActionListener(e -> {
     547                JRadioButtonMenuItem item = (buttonHiding == ButtonHidingType.DYNAMIC) ? alwaysShown : dynamic;
     548                item.setSelected(true);
     549                item.getAction().actionPerformed(null);
     550            });
    556551            add(buttonsHide);
    557552
    … …  
    561556                pref.setToolTipText(tr("Open preferences for this panel"));
    562557                pref.setBorder(BorderFactory.createEmptyBorder());
    563                 pref.addActionListener(
    564                         new ActionListener() {
    565                             @Override
    566                             @SuppressWarnings("unchecked")
    567                             public void actionPerformed(ActionEvent e) {
    568                                 final PreferenceDialog p = new PreferenceDialog(Main.parent);
    569                                 if (TabPreferenceSetting.class.isAssignableFrom(preferenceClass)) {
    570                                     p.selectPreferencesTabByClass((Class<? extends TabPreferenceSetting>) preferenceClass);
    571                                 } else if (SubPreferenceSetting.class.isAssignableFrom(preferenceClass)) {
    572                                     p.selectSubPreferencesTabByClass((Class<? extends SubPreferenceSetting>) preferenceClass);
    573                                 }
    574                                 p.setVisible(true);
    575                             }
    576                         }
    577                         );
     558                pref.addActionListener(e -> {
     559                    final PreferenceDialog p = new PreferenceDialog(Main.parent);
     560                    if (TabPreferenceSetting.class.isAssignableFrom(preferenceClass)) {
     561                        p.selectPreferencesTabByClass((Class<? extends TabPreferenceSetting>) preferenceClass);
     562                    } else if (SubPreferenceSetting.class.isAssignableFrom(preferenceClass)) {
     563                        p.selectSubPreferencesTabByClass((Class<? extends SubPreferenceSetting>) preferenceClass);
     564                    }
     565                    p.setVisible(true);
     566                });
    578567                add(pref);
    579568            }
    … …  
    583572            sticky.setToolTipText(tr("Undock the panel"));
    584573            sticky.setBorder(BorderFactory.createEmptyBorder());
    585             sticky.addActionListener(
    586                     new ActionListener() {
    587                         @Override
    588                         public void actionPerformed(ActionEvent e) {
    589                             detach();
    590                             dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
    591                         }
    592                     }
    593                     );
     574            sticky.addActionListener(e -> {
     575                detach();
     576                dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
     577            });
    594578            add(sticky);
    595579
    … …  
    598582            close.setToolTipText(tr("Close this panel. You can reopen it with the buttons in the left toolbar."));
    599583            close.setBorder(BorderFactory.createEmptyBorder());
    600             close.addActionListener(
    601                     new ActionListener() {
    602                         @Override
    603                         public void actionPerformed(ActionEvent e) {
    604                             hideDialog();
    605                             dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
    606                             hideNotify();
    607                         }
    608                     }
    609                     );
     584            close.addActionListener(e -> {
     585                hideDialog();
     586                dialogsPanel.reconstruct(Action.ELEMENT_SHRINKS, null);
     587                hideNotify();
     588            });
    610589            add(close);
    611590            setToolTipText(tr("Click to minimize/maximize the panel content"));

  • trunk/src/org/openstreetmap/josm/gui/dialogs/UserListDialog.java

    r10446 r10611  
    129129    public void refresh(Collection<? extends OsmPrimitive> fromPrimitives) {
    130130        model.populate(fromPrimitives);
    131         GuiHelper.runInEDT(new Runnable() {
    132             @Override
    133             public void run() {
    134                 if (model.getRowCount() != 0) {
    135                     setTitle(trn("{0} Author", "{0} Authors", model.getRowCount(), model.getRowCount()));
    136                 } else {
    137                     setTitle(tr("Authors"));
    138                 }
     131        GuiHelper.runInEDT(() -> {
     132            if (model.getRowCount() != 0) {
     133                setTitle(trn("{0} Author", "{0} Authors", model.getRowCount(), model.getRowCount()));
     134            } else {
     135                setTitle(tr("Authors"));
    139136            }
    140137        });
    … …  
    320317            }
    321318            Collections.sort(data);
    322             GuiHelper.runInEDTAndWait(new Runnable() {
    323                 @Override
    324                 public void run() {
    325                     fireTableDataChanged();
    326                 }
    327             });
     319            GuiHelper.runInEDTAndWait(this::fireTableDataChanged);
    328320        }
    329321

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

    r10593 r10611  
    593593                final Command fixCommand = error.getFix();
    594594                if (fixCommand != null) {
    595                     SwingUtilities.invokeAndWait(new Runnable() {
    596                         @Override
    597                         public void run() {
    598                             Main.main.undoRedo.addNoRedraw(fixCommand);
    599                         }
    600                     });
     595                    SwingUtilities.invokeAndWait(() -> Main.main.undoRedo.addNoRedraw(fixCommand));
    601596                }
    602597                // It is wanted to ignore an error if it said fixable, even if fixCommand was null
    … …  
    614609                final DataSet ds = Main.getLayerManager().getEditDataSet();
    615610                int i = 0;
    616                 SwingUtilities.invokeAndWait(new Runnable() {
    617                     @Override
    618                     public void run() {
    619                         ds.beginUpdate();
    620                     }
    621                 });
     611                SwingUtilities.invokeAndWait(ds::beginUpdate);
    622612                try {
    623613                    for (TestError error: testErrors) {
    … …  
    630620                    }
    631621                } finally {
    632                     SwingUtilities.invokeAndWait(new Runnable() {
    633                         @Override
    634                         public void run() {
    635                             ds.endUpdate();
    636                         }
    637                     });
     622                    SwingUtilities.invokeAndWait(ds::endUpdate);
    638623                }
    639624                monitor.subTask(tr("Updating map ..."));
    640                 SwingUtilities.invokeAndWait(new Runnable() {
    641                     @Override
    642                     public void run() {
    643                         Main.main.undoRedo.afterAdd();
    644                         Main.map.repaint();
    645                         tree.resetErrors();
    646                         ds.fireSelectionChanged();
    647                     }
     625                SwingUtilities.invokeAndWait(() -> {
     626                    Main.main.undoRedo.afterAdd();
     627                    Main.map.repaint();
     628                    tree.resetErrors();
     629                    ds.fireSelectionChanged();
    648630                });
    649631            } catch (InterruptedException | InvocationTargetException e) {
    650                 // FIXME: signature of realRun should have a generic checked exception we
    651                 // could throw here
     632                // FIXME: signature of realRun should have a generic checked exception we could throw here
    652633                throw new RuntimeException(e);
    653634            } finally {

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManager.java

    r10447 r10611  
    653653        if (idx < 0)
    654654            return;
    655         GuiHelper.runInEDTAndWait(new Runnable() {
    656             @Override
    657             public void run() {
    658                 tblChangesets.scrollRectToVisible(tblChangesets.getCellRect(idx, 0, true));
    659             }
    660         });
     655        GuiHelper.runInEDTAndWait(() -> tblChangesets.scrollRectToVisible(tblChangesets.getCellRect(idx, 0, true)));
    661656        repaint();
    662657    }
    … …  
    702697    public void runDownloadTask(final AbstractChangesetDownloadTask task) {
    703698        Main.worker.submit(new PostDownloadHandler(task, task.download()));
    704         Main.worker.submit(new Runnable() {
    705             @Override
    706             public void run() {
    707                 if (task.isCanceled() || task.isFailed())
    708                     return;
    709                 setSelectedChangesets(task.getDownloadedData());
    710             }
     699        Main.worker.submit(() -> {
     700            if (task.isCanceled() || task.isFailed())
     701                return;
     702            setSelectedChangesets(task.getDownloadedData());
    711703        });
    712704    }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManagerModel.java

    r9078 r10611  
    77import java.util.Collection;
    88import java.util.Collections;
    9 import java.util.Comparator;
    109import java.util.HashSet;
    1110import java.util.List;
    … …  
    105104     */
    106105    public void setSelectedChangesets(Collection<Changeset> selected) {
    107         GuiHelper.runInEDTAndWait(new Runnable() {
    108             @Override public void run() {
    109                 selectionModel.clearSelection();
    110             }
    111         });
     106        GuiHelper.runInEDTAndWait(selectionModel::clearSelection);
    112107        if (selected == null || selected.isEmpty())
    113108            return;
    … …  
    115110            final int idx = data.indexOf(cs);
    116111            if (idx >= 0) {
    117                 GuiHelper.runInEDTAndWait(new Runnable() {
    118                     @Override public void run() {
    119                         selectionModel.addSelectionInterval(idx, idx);
    120                     }
    121                 });
     112                GuiHelper.runInEDTAndWait(() -> selectionModel.addSelectionInterval(idx, idx));
    122113            }
    123114        }
    … …  
    162153        Collections.sort(
    163154                this.data,
    164                 new Comparator<Changeset>() {
    165                     @Override public int compare(Changeset o1, Changeset o2) {
    166                         if (o1.getId() < o2.getId()) return 1;
    167                         if (o1.getId() == o2.getId()) return 0;
    168                         return -1;
    169                     }
     155                (o1, o2) -> {
     156                    if (o1.getId() < o2.getId()) return 1;
     157                    if (o1.getId() == o2.getId()) return 0;
     158                    return -1;
    170159                }
    171160        );

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentPanel.java

    r10490 r10611  
    5454import org.openstreetmap.josm.tools.ImageProvider;
    5555import org.openstreetmap.josm.tools.Utils;
     56import org.openstreetmap.josm.tools.Utils.Function;
    5657import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    5758
    … …  
    233234                            continue;
    234235                        }
    235                         GuiHelper.runInEDT(new Runnable() {
    236                             @Override
    237                             public void run() {
    238                                 HistoryBrowserDialogManager.getInstance().show(h);
    239                             }
    240                         });
     236                        GuiHelper.runInEDT(() -> HistoryBrowserDialogManager.getInstance().show(h));
    241237                    }
    242238                } catch (final RuntimeException e) {
    243                     GuiHelper.runInEDT(new Runnable() {
    244                         @Override
    245                         public void run() {
    246                             BugReportExceptionHandler.handleException(e);
    247                         }
    248                     });
     239                    GuiHelper.runInEDT(() -> BugReportExceptionHandler.handleException(e));
    249240                }
    250241            }
    … …  
    311302        public void actionPerformed(ActionEvent arg0) {
    312303            final List<PrimitiveId> primitiveIds = new ArrayList<>(Utils.transform(
    313                     model.getSelectedPrimitives(), new Utils.Function<HistoryOsmPrimitive, PrimitiveId>() {
    314                         @Override
    315                         public PrimitiveId apply(HistoryOsmPrimitive x) {
    316                             return x.getPrimitiveId();
    317                         }
    318                     }));
     304                    model.getSelectedPrimitives(), (Function<HistoryOsmPrimitive, PrimitiveId>) x -> x.getPrimitiveId()));
    319305            Main.worker.submit(new DownloadPrimitivesWithReferrersTask(false, primitiveIds, true, true, null, null));
    320306        }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentTableModel.java

    r9078 r10611  
    44import java.util.ArrayList;
    55import java.util.Collections;
    6 import java.util.Comparator;
    76import java.util.HashSet;
    87import java.util.Iterator;
    … …  
    8382        Collections.sort(
    8483                data,
    85                 new Comparator<ChangesetDataSetEntry>() {
    86                     @Override
    87                     public int compare(ChangesetDataSetEntry c1, ChangesetDataSetEntry c2) {
    88                         if (c1.getModificationType().equals(c2.getModificationType())) {
    89                             long id1 = c1.getPrimitive().getId();
    90                             long id2 = c2.getPrimitive().getId();
     84                (c1, c2) -> {
     85                    if (c1.getModificationType().equals(c2.getModificationType())) {
     86                        long id1 = c1.getPrimitive().getId();
     87                        long id2 = c2.getPrimitive().getId();
    9188
    92                             if (id1 == id2)
    93                                 return 0;
    94                             else if (id1 < id2)
    95                                 return -1;
    96                             return 1;
     89                        if (id1 == id2)
     90                            return 0;
     91                        else if (id1 < id2)
     92                            return -1;
     93                        return 1;
     94                    }
     95                    switch(c1.getModificationType()) {
     96                    case CREATED: return -1;
     97                    case UPDATED:
     98                        switch(c2.getModificationType()) {
     99                        case CREATED: return 1;
     100                        default: return -1;
    97101                        }
    98                         switch(c1.getModificationType()) {
    99                         case CREATED: return -1;
    100                         case UPDATED:
    101                             switch(c2.getModificationType()) {
    102                             case CREATED: return 1;
    103                             default: return -1;
    104                             }
    105                         case DELETED:
    106                             return 1;
    107                         }
    108                         // should not happen
    109                         return 0;
     102                    case DELETED:
     103                        return 1;
    110104                    }
     105                    // should not happen
     106                    return 0;
    111107                }
    112108        );

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetDiscussionPanel.java

    r10438 r10611  
    116116        JPanel pnl = new JPanel(new BorderLayout());
    117117        table = new JTable(model, new ChangesetDiscussionTableColumnModel());
    118         table.getColumnModel().getColumn(2).addPropertyChangeListener(new PropertyChangeListener() {
    119             @Override
    120             public void propertyChange(PropertyChangeEvent evt) {
    121                 if ("width".equals(evt.getPropertyName())) {
    122                     updateRowHeights();
    123                 }
     118        table.getColumnModel().getColumn(2).addPropertyChangeListener(evt -> {
     119            if ("width".equals(evt.getPropertyName())) {
     120                updateRowHeights();
    124121            }
    125122        });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetListModel.java

    r9078 r10611  
    55import java.util.Collection;
    66import java.util.Collections;
    7 import java.util.Comparator;
    87import java.util.HashSet;
    98import java.util.List;
    … …  
    143142        Collections.sort(
    144143                data,
    145                 new Comparator<Changeset>() {
    146                     @Override
    147                     public int compare(Changeset cs1, Changeset cs2) {
    148                         if (cs1.getId() > cs2.getId()) return -1;
    149                         if (cs1.getId() == cs2.getId()) return 0;
    150                         return 1;
    151                     }
     144                (cs1, cs2) -> {
     145                    if (cs1.getId() > cs2.getId()) return -1;
     146                    if (cs1.getId() == cs2.getId()) return 0;
     147                    return 1;
    152148                }
    153149        );

  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/UrlBasedQueryPanel.java

    r10378 r10611  
    1919import javax.swing.event.DocumentListener;
    2020import javax.swing.event.HyperlinkEvent;
    21 import javax.swing.event.HyperlinkListener;
    2221
    2322import org.openstreetmap.josm.Main;
    … …  
    8685                        + "</body></html>"
    8786        );
    88         pnl.getEditorPane().addHyperlinkListener(
    89                 new HyperlinkListener() {
    90                     @Override
    91                     public void hyperlinkUpdate(HyperlinkEvent e) {
    92                         if (e.getEventType().equals(HyperlinkEvent.EventType.ACTIVATED)) {
    93                             tfUrl.setText(e.getDescription());
    94                             tfUrl.requestFocusInWindow();
    95                         }
    96                     }
     87        pnl.getEditorPane().addHyperlinkListener(e -> {
     88                if (e.getEventType().equals(HyperlinkEvent.EventType.ACTIVATED)) {
     89                    tfUrl.setText(e.getDescription());
     90                    tfUrl.requestFocusInWindow();
    9791                }
    98         );
     92            });
    9993        return pnl;
    10094    }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/layer/ActivateLayerAction.java

    r10600 r10611  
    8888    @Override
    8989    public void updateEnabledState() {
    90         GuiHelper.runInEDTAndWait(new Runnable() {
    91             @Override
    92             public void run() {
    93                 if (layer == null) {
    94                     if (model.getSelectedLayers().size() != 1) {
    95                         setEnabled(false);
    96                         return;
    97                     }
    98                     setEnabled(!isActiveLayer(model.getSelectedLayers().get(0)));
    99                 } else {
    100                     setEnabled(!isActiveLayer(layer));
     90        GuiHelper.runInEDTAndWait(() -> {
     91            if (layer == null) {
     92                if (model.getSelectedLayers().size() != 1) {
     93                    setEnabled(false);
     94                    return;
    10195                }
     96                setEnabled(!isActiveLayer(model.getSelectedLayers().get(0)));
     97            } else {
     98                setEnabled(!isActiveLayer(layer));
    10299            }
    103100        });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/layer/LayerVisibilityAction.java

    r10600 r10611  
    2020import javax.swing.JPopupMenu;
    2121import javax.swing.JSlider;
    22 import javax.swing.event.ChangeEvent;
    23 import javax.swing.event.ChangeListener;
    2422
    2523import org.openstreetmap.josm.Main;
    … …  
    6967
    7068        visibilityCheckbox = new JCheckBox(tr("Show layer"));
    71         visibilityCheckbox.addChangeListener(new ChangeListener() {
    72             @Override
    73             public void stateChanged(ChangeEvent e) {
    74                 setVisibleFlag(visibilityCheckbox.isSelected());
    75             }
    76         });
     69        visibilityCheckbox.addChangeListener(e -> setVisibleFlag(visibilityCheckbox.isSelected()));
    7770        content.add(visibilityCheckbox, GBC.eop());
    7871
    … …  
    178171            setPaintTicks(true);
    179172
    180             addChangeListener(new ChangeListener() {
    181                 @Override
    182                 public void stateChanged(ChangeEvent e) {
    183                     onStateChanged();
    184                 }
    185             });
     173            addChangeListener(e -> onStateChanged());
    186174        }
    187175

  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r10604 r10611  
    1414import java.awt.event.MouseAdapter;
    1515import java.awt.event.MouseEvent;
    16 import java.beans.PropertyChangeEvent;
    17 import java.beans.PropertyChangeListener;
    1816import java.io.IOException;
    1917import java.net.URI;
    … …  
    2321import java.util.Collection;
    2422import java.util.Collections;
    25 import java.util.Comparator;
    2623import java.util.EnumSet;
    2724import java.util.HashMap;
    … …  
    319316        tagRowSorter.addRowSorterListener(removeHiddenSelection);
    320317        tagRowSorter.setComparator(0, AlphanumComparator.getInstance());
    321         tagRowSorter.setComparator(1, new Comparator<Object>() {
    322             @Override
    323             public int compare(Object o1, Object o2) {
    324                 if (o1 instanceof Map && o2 instanceof Map) {
    325                     final String v1 = ((Map) o1).size() == 1 ? (String) ((Map) o1).keySet().iterator().next() : tr("<different>");
    326                     final String v2 = ((Map) o2).size() == 1 ? (String) ((Map) o2).keySet().iterator().next() : tr("<different>");
    327                     return AlphanumComparator.getInstance().compare(v1, v2);
    328                 } else {
    329                     return AlphanumComparator.getInstance().compare(String.valueOf(o1), String.valueOf(o2));
    330                 }
     318        tagRowSorter.setComparator(1, (o1, o2) -> {
     319            if (o1 instanceof Map && o2 instanceof Map) {
     320                final String v1 = ((Map) o1).size() == 1 ? (String) ((Map) o1).keySet().iterator().next() : tr("<different>");
     321                final String v2 = ((Map) o2).size() == 1 ? (String) ((Map) o2).keySet().iterator().next() : tr("<different>");
     322                return AlphanumComparator.getInstance().compare(v1, v2);
     323            } else {
     324                return AlphanumComparator.getInstance().compare(String.valueOf(o1), String.valueOf(o2));
    331325            }
    332326        });
    … …  
    545539        f.setToolTipText(tr("Tag filter"));
    546540        final CompileSearchTextDecorator decorator = CompileSearchTextDecorator.decorate(f);
    547         f.addPropertyChangeListener("filter", new PropertyChangeListener() {
    548             @Override
    549             public void propertyChange(PropertyChangeEvent evt) {
    550                 setFilter(decorator.getMatch());
    551             }
    552         });
     541        f.addPropertyChangeListener("filter", evt -> setFilter(decorator.getMatch()));
    553542        return f;
    554543    }
    … …  
    713702
    714703        List<Relation> sortedRelations = new ArrayList<>(roles.keySet());
    715         Collections.sort(sortedRelations, new Comparator<Relation>() {
    716             @Override
    717             public int compare(Relation o1, Relation o2) {
    718                 int comp = Boolean.compare(o1.isDisabledAndHidden(), o2.isDisabledAndHidden());
    719                 return comp != 0 ? comp : DefaultNameFormatter.getInstance().getRelationComparator().compare(o1, o2);
    720             }
     704        Collections.sort(sortedRelations, (o1, o2) -> {
     705            int comp = Boolean.compare(o1.isDisabledAndHidden(), o2.isDisabledAndHidden());
     706            return comp != 0 ? comp : DefaultNameFormatter.getInstance().getRelationComparator().compare(o1, o2);
    721707        });
    722708
    … …  
    11751161                }
    11761162
    1177                 Main.worker.execute(new Runnable() {
    1178                     @Override public void run() {
    1179                         try {
    1180                             // find a page that actually exists in the wiki
    1181                             HttpClient.Response conn;
    1182                             for (URI u : uris) {
    1183                                 conn = HttpClient.create(u.toURL(), "HEAD").connect();
    1184 
    1185                                 if (conn.getResponseCode() != 200) {
     1163                Main.worker.execute(() -> {
     1164                    try {
     1165                        // find a page that actually exists in the wiki
     1166                        HttpClient.Response conn;
     1167                        for (URI u : uris) {
     1168                            conn = HttpClient.create(u.toURL(), "HEAD").connect();
     1169
     1170                            if (conn.getResponseCode() != 200) {
     1171                                conn.disconnect();
     1172                            } else {
     1173                                long osize = conn.getContentLength();
     1174                                if (osize > -1) {
     1175                                    conn.disconnect();
     1176
     1177                                    final URI newURI = new URI(u.toString()
     1178                                            .replace("=", "%3D") /* do not URLencode whole string! */
     1179                                            .replaceFirst("/wiki/", "/w/index.php?redirect=no&title=")
     1180                                    );
     1181                                    conn = HttpClient.create(newURI.toURL(), "HEAD").connect();
     1182                                }
     1183
     1184                                /* redirect pages have different content length, but retrieving a "nonredirect"
     1185                                 *  page using index.php and the direct-link method gives slightly different
     1186                                 *  content lengths, so we have to be fuzzy.. (this is UGLY, recode if u know better)
     1187                                 */
     1188                                if (conn.getContentLength() != -1 && osize > -1 && Math.abs(conn.getContentLength() - osize) > 200) {
     1189                                    Main.info("{0} is a mediawiki redirect", u);
    11861190                                    conn.disconnect();
    11871191                                } else {
    1188                                     long osize = conn.getContentLength();
    1189                                     if (osize > -1) {
    1190                                         conn.disconnect();
    1191 
    1192                                         final URI newURI = new URI(u.toString()
    1193                                                 .replace("=", "%3D") /* do not URLencode whole string! */
    1194                                                 .replaceFirst("/wiki/", "/w/index.php?redirect=no&title=")
    1195                                         );
    1196                                         conn = HttpClient.create(newURI.toURL(), "HEAD").connect();
    1197                                     }
    1198 
    1199                                     /* redirect pages have different content length, but retrieving a "nonredirect"
    1200                                      *  page using index.php and the direct-link method gives slightly different
    1201                                      *  content lengths, so we have to be fuzzy.. (this is UGLY, recode if u know better)
    1202                                      */
    1203                                     if (conn.getContentLength() != -1 && osize > -1 && Math.abs(conn.getContentLength() - osize) > 200) {
    1204                                         Main.info("{0} is a mediawiki redirect", u);
    1205                                         conn.disconnect();
    1206                                     } else {
    1207                                         conn.disconnect();
    1208 
    1209                                         OpenBrowser.displayUrl(u.toString());
    1210                                         break;
    1211                                     }
     1192                                    conn.disconnect();
     1193
     1194                                    OpenBrowser.displayUrl(u.toString());
     1195                                    break;
    12121196                                }
    12131197                            }
    1214                         } catch (URISyntaxException | IOException e) {
    1215                             Main.error(e);
    12161198                        }
     1199                    } catch (URISyntaxException | IOException e1) {
     1200                        Main.error(e1);
    12171201                    }
    12181202                });

  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/TagEditHelper.java

    r10604 r10611  
    1717import java.awt.datatransfer.Transferable;
    1818import java.awt.event.ActionEvent;
    19 import java.awt.event.ActionListener;
    2019import java.awt.event.FocusAdapter;
    2120import java.awt.event.FocusEvent;
    … …  
    108107    private String objKey;
    109108
    110     private final Comparator<AutoCompletionListItem> defaultACItemComparator = new Comparator<AutoCompletionListItem>() {
    111         @Override
    112         public int compare(AutoCompletionListItem o1, AutoCompletionListItem o2) {
    113             return String.CASE_INSENSITIVE_ORDER.compare(o1.getValue(), o2.getValue());
    114         }
    115     };
     109    private final Comparator<AutoCompletionListItem> defaultACItemComparator =
     110            (o1, o2) -> String.CASE_INSENSITIVE_ORDER.compare(o1.getValue(), o2.getValue());
    116111
    117112    private String lastAddKey;
    … …  
    365360        private final String key;
    366361        private final transient Map<String, Integer> m;
    367 
    368         private final transient Comparator<AutoCompletionListItem> usedValuesAwareComparator = new Comparator<AutoCompletionListItem>() {
    369                 @Override
    370                 public int compare(AutoCompletionListItem o1, AutoCompletionListItem o2) {
    371                     boolean c1 = m.containsKey(o1.getValue());
    372                     boolean c2 = m.containsKey(o2.getValue());
    373                     if (c1 == c2)
    374                         return String.CASE_INSENSITIVE_ORDER.compare(o1.getValue(), o2.getValue());
    375                     else if (c1)
    376                         return -1;
    377                     else
    378                         return +1;
    379                 }
    380             };
     362        private final transient Comparator<AutoCompletionListItem> usedValuesAwareComparator;
    381363
    382364        private final transient ListCellRenderer<AutoCompletionListItem> cellRenderer = new ListCellRenderer<AutoCompletionListItem>() {
    … …  
    409391            this.m = map;
    410392
     393            usedValuesAwareComparator = (o1, o2) -> {
     394                boolean c1 = m.containsKey(o1.getValue());
     395                boolean c2 = m.containsKey(o2.getValue());
     396                if (c1 == c2)
     397                    return String.CASE_INSENSITIVE_ORDER.compare(o1.getValue(), o2.getValue());
     398                else if (c1)
     399                    return -1;
     400                else
     401                    return +1;
     402            };
     403
    411404            JPanel mainPanel = new JPanel(new BorderLayout());
    412405
    … …  
    450443            p.add(Box.createHorizontalStrut(10), GBC.std());
    451444            p.add(values, GBC.eol().fill(GBC.HORIZONTAL));
    452             values.getEditor().addActionListener(new ActionListener() {
    453                 @Override
    454                 public void actionPerformed(ActionEvent e) {
    455                     buttonAction(0, null); // emulate OK button click
    456                 }
    457             });
     445            values.getEditor().addActionListener(e -> buttonAction(0, null));
    458446            addFocusAdapter(autocomplete, usedValuesAwareComparator);
    459447

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ChildRelationBrowser.java

    r10378 r10611  
    420420                    refreshView(r);
    421421                }
    422                 SwingUtilities.invokeLater(new Runnable() {
    423                     @Override
    424                     public void run() {
    425                         Main.map.repaint();
    426                     }
    427                 });
     422                SwingUtilities.invokeLater(() -> Main.map.repaint());
    428423            } catch (OsmTransferException e) {
    429424                if (canceled) {

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationMemberTask.java

    r10212 r10611  
    133133            }
    134134
    135             SwingUtilities.invokeLater(
    136                     new Runnable() {
    137                         @Override
    138                         public void run() {
    139                             curLayer.mergeFrom(dataSet);
    140                             curLayer.onPostDownloadFromServer();
    141                         }
    142                     }
    143             );
    144 
     135            SwingUtilities.invokeLater(() -> {
     136                curLayer.mergeFrom(dataSet);
     137                curLayer.onPostDownloadFromServer();
     138            });
    145139        } catch (OsmTransferException e) {
    146140            if (canceled) {

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationTask.java

    r10212 r10611  
    9898            }
    9999
    100             SwingUtilities.invokeAndWait(
    101                     new Runnable() {
    102                         @Override
    103                         public void run() {
    104                             layer.mergeFrom(allDownloads);
    105                             layer.onPostDownloadFromServer();
    106                             Main.map.repaint();
    107                         }
    108                     }
    109             );
     100            SwingUtilities.invokeAndWait(() -> {
     101                layer.mergeFrom(allDownloads);
     102                layer.onPostDownloadFromServer();
     103                Main.map.repaint();
     104            });
    110105        } catch (OsmTransferException | InvocationTargetException | InterruptedException e) {
    111106            if (canceled) {

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r10604 r10611  
    4747import javax.swing.JToolBar;
    4848import javax.swing.KeyStroke;
    49 import javax.swing.event.ChangeEvent;
    50 import javax.swing.event.ChangeListener;
    51 import javax.swing.event.ListSelectionEvent;
    52 import javax.swing.event.ListSelectionListener;
    5349
    5450import org.openstreetmap.josm.Main;
    … …  
    232228        tabbedPane.add(tr("Parent Relations"), referrerBrowser);
    233229        tabbedPane.add(tr("Child Relations"), new ChildRelationBrowser(getLayer(), relation));
    234         tabbedPane.addChangeListener(
    235                 new ChangeListener() {
    236                     @Override
    237                     public void stateChanged(ChangeEvent e) {
    238                         JTabbedPane sourceTabbedPane = (JTabbedPane) e.getSource();
    239                         int index = sourceTabbedPane.getSelectedIndex();
    240                         String title = sourceTabbedPane.getTitleAt(index);
    241                         if (title.equals(tr("Parent Relations"))) {
    242                             referrerBrowser.init();
    243                         }
    244                     }
    245                 }
    246         );
     230        tabbedPane.addChangeListener(e -> {
     231            JTabbedPane sourceTabbedPane = (JTabbedPane) e.getSource();
     232            int index = sourceTabbedPane.getSelectedIndex();
     233            String title = sourceTabbedPane.getTitleAt(index);
     234            if (title.equals(tr("Parent Relations"))) {
     235                referrerBrowser.init();
     236            }
     237        });
    247238
    248239        refreshAction = new RefreshAction(memberTable, memberTableModel, tagEditorPanel.getModel(), getLayer(), this);
    … …  
    487478        tfRole.addActionListener(setRoleAction);
    488479        memberTableModel.getSelectionModel().addListSelectionListener(
    489                 new ListSelectionListener() {
    490                     @Override
    491                     public void valueChanged(ListSelectionEvent e) {
    492                         tfRole.setEnabled(memberTable.getSelectedRowCount() > 0);
    493                     }
    494                 }
     480                e -> tfRole.setEnabled(memberTable.getSelectedRowCount() > 0)
    495481        );
    496482        tfRole.setEnabled(memberTable.getSelectedRowCount() > 0);

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTable.java

    r10604 r10611  
    105105    }
    106106
    107     private transient ListSelectionListener highlighterListener = new ListSelectionListener() {
    108         @Override
    109         public void valueChanged(ListSelectionEvent lse) {
    110             if (Main.isDisplayingMapView()) {
    111                 Collection<RelationMember> sel = getMemberTableModel().getSelectedMembers();
    112                 final List<OsmPrimitive> toHighlight = new ArrayList<>();
    113                 for (RelationMember r: sel) {
    114                     if (r.getMember().isUsable()) {
    115                         toHighlight.add(r.getMember());
    116                     }
     107    private transient ListSelectionListener highlighterListener = lse -> {
     108        if (Main.isDisplayingMapView()) {
     109            Collection<RelationMember> sel = getMemberTableModel().getSelectedMembers();
     110            final List<OsmPrimitive> toHighlight = new ArrayList<>();
     111            for (RelationMember r: sel) {
     112                if (r.getMember().isUsable()) {
     113                    toHighlight.add(r.getMember());
    117114                }
    118                 SwingUtilities.invokeLater(new Runnable() {
    119                     @Override
    120                     public void run() {
    121                         if (Main.isDisplayingMapView() && highlightHelper.highlightOnly(toHighlight)) {
    122                             Main.map.mapView.repaint();
    123                         }
    124                     }
    125                 });
    126             }
     115            }
     116            SwingUtilities.invokeLater(() -> {
     117                if (Main.isDisplayingMapView() && highlightHelper.highlightOnly(toHighlight)) {
     118                    Main.map.mapView.repaint();
     119                }
     120            });
    127121        }
    128122    };

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java

    r10604 r10611  
    122122        // just trigger a repaint - the display name of the relation members may have changed
    123123        Collection<RelationMember> sel = getSelectedMembers();
    124         GuiHelper.runInEDT(new Runnable() {
    125             @Override
    126             public void run() {
    127                 fireTableDataChanged();
    128             }
    129         });
     124        GuiHelper.runInEDT(() -> fireTableDataChanged());
    130125        setSelectedMembers(sel);
    131126    }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ParentRelationLoadingTask.java

    r10413 r10611  
    165165                // copy the merged layer's data source info
    166166                getLayer().data.dataSources.addAll(referrers.dataSources);
    167                 // FIXME: this is necessary because there are  dialogs listening
     167                // FIXME: this is necessary because there are dialogs listening
    168168                // for DataChangeEvents which manipulate Swing components on this thread.
    169                 //
    170                 SwingUtilities.invokeLater(
    171                         new Runnable() {
    172                             @Override
    173                             public void run() {
    174                                 getLayer().onPostDownloadFromServer();
    175                             }
    176                         }
    177                 );
     169                SwingUtilities.invokeLater(() -> getLayer().onPostDownloadFromServer());
    178170
    179171                if (visitor.getConflicts().isEmpty())

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ReferringRelationsBrowser.java

    r10424 r10611  
    110110                    new PleaseWaitProgressMonitor(tr("Loading parent relations"))
    111111            );
    112             task.setContinuation(
    113                     new Runnable() {
    114                         @Override
    115                         public void run() {
    116                             if (task.isCanceled() || task.hasError())
    117                                 return;
    118                             model.populate(task.getParents());
    119                         }
    120                     }
    121             );
     112            task.setContinuation(() -> {
     113                    if (task.isCanceled() || task.hasError())
     114                        return;
     115                    model.populate(task.getParents());
     116                });
    122117            Main.worker.submit(task);
    123118        }

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationTree.java

    r10413 r10611  
    141141            }
    142142            final RelationTreeModel model = (RelationTreeModel) getModel();
    143             SwingUtilities.invokeLater(
    144                     new Runnable() {
    145                         @Override
    146                         public void run() {
    147                             model.refreshNode(path);
    148                         }
    149                     }
    150             );
     143            SwingUtilities.invokeLater(() -> model.refreshNode(path));
    151144        }
    152145

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/actions/SavingAction.java

    r9665 r10611  
    2121import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2222import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     23import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    2324import org.openstreetmap.josm.gui.dialogs.relation.MemberTable;
    2425import org.openstreetmap.josm.gui.dialogs.relation.MemberTableModel;
    25 import org.openstreetmap.josm.gui.dialogs.relation.IRelationEditor;
    2626import org.openstreetmap.josm.gui.dialogs.relation.RelationDialogManager;
    2727import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
    … …  
    8181                    layer, editor.getRelation(), (RelationEditor) editor);
    8282        }
    83         SwingUtilities.invokeLater(new Runnable() {
    84             @Override
    85             public void run() {
    86                 // Relation list gets update in EDT so selecting my be postponed to following EDT run
    87                 Main.map.relationListDialog.selectRelation(newRelation);
    88             }
    89         });
     83        // Relation list gets update in EDT so selecting my be postponed to following EDT run
     84        SwingUtilities.invokeLater(() -> Main.map.relationListDialog.selectRelation(newRelation));
    9085    }
    9186

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationSorter.java

    r10179 r10611  
    55import java.util.Collection;
    66import java.util.Collections;
    7 import java.util.Comparator;
    87import java.util.HashMap;
    98import java.util.LinkedHashMap;
    … …  
    6665        @Override
    6766        public List<RelationMember> sortMembers(List<RelationMember> list) {
    68             Collections.sort(list, new Comparator<RelationMember>() {
    69                 @Override
    70                 public int compare(RelationMember a, RelationMember b) {
    71                     final int houseNumber = AlphanumComparator.getInstance().compare(
    72                             a.getMember().get("addr:housenumber"),
    73                             b.getMember().get("addr:housenumber"));
    74                     if (houseNumber != 0) {
    75                         return houseNumber;
    76                     }
    77                     final String aDisplayName = a.getMember().getDisplayName(DefaultNameFormatter.getInstance());
    78                     final String bDisplayName = b.getMember().getDisplayName(DefaultNameFormatter.getInstance());
    79                     return AlphanumComparator.getInstance().compare(aDisplayName, bDisplayName);
    80                 }
     67            Collections.sort(list, (a, b) -> {
     68                final int houseNumber = AlphanumComparator.getInstance().compare(
     69                        a.getMember().get("addr:housenumber"),
     70                        b.getMember().get("addr:housenumber"));
     71                if (houseNumber != 0) {
     72                    return houseNumber;
     73                }
     74                final String aDisplayName = a.getMember().getDisplayName(DefaultNameFormatter.getInstance());
     75                final String bDisplayName = b.getMember().getDisplayName(DefaultNameFormatter.getInstance());
     76                return AlphanumComparator.getInstance().compare(aDisplayName, bDisplayName);
    8177            });
    8278            return list;

  • trunk/src/org/openstreetmap/josm/gui/dialogs/validator/ValidatorTreePanel.java

    r10446 r10611  
    147147
    148148        if (errors == null || errors.isEmpty()) {
    149             GuiHelper.runInEDTAndWait(new Runnable() {
    150                 @Override
    151                 public void run() {
    152                     valTreeModel.setRoot(rootNode);
    153                 }
    154             });
     149            GuiHelper.runInEDTAndWait(() -> valTreeModel.setRoot(rootNode));
    155150            return;
    156151        }

  • trunk/src/org/openstreetmap/josm/gui/download/BookmarkSelection.java

    r10378 r10611  
    110110
    111111        bookmarks = new BookmarkList();
    112         bookmarks.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
    113             @Override
    114             public void valueChanged(ListSelectionEvent e) {
    115                 Bookmark b = bookmarks.getSelectedValue();
    116                 if (b != null && gui != null) {
    117                     gui.boundingBoxChanged(b.getArea(), BookmarkSelection.this);
    118                 }
     112        bookmarks.getSelectionModel().addListSelectionListener(e -> {
     113            Bookmark b = bookmarks.getSelectedValue();
     114            if (b != null && gui != null) {
     115                gui.boundingBoxChanged(b.getArea(), BookmarkSelection.this);
    119116            }
    120117        });

  • trunk/src/org/openstreetmap/josm/gui/download/DownloadDialog.java

    r10604 r10611  
    1414import java.awt.GridBagLayout;
    1515import java.awt.event.ActionEvent;
    16 import java.awt.event.ActionListener;
    1716import java.awt.event.InputEvent;
    1817import java.awt.event.KeyEvent;
    … …  
    3231import javax.swing.JTabbedPane;
    3332import javax.swing.KeyStroke;
    34 import javax.swing.event.ChangeEvent;
    3533import javax.swing.event.ChangeListener;
    3634
    … …  
    9492        JPanel pnl = new JPanel(new GridBagLayout());
    9593
    96         final ChangeListener checkboxChangeListener = new ChangeListener() {
    97             @Override
    98             public void stateChanged(ChangeEvent e) {
    99                 // size check depends on selected data source
    100                 updateSizeCheck();
    101             }
    102         };
     94        // size check depends on selected data source
     95        final ChangeListener checkboxChangeListener = e -> updateSizeCheck();
    10396
    10497        // adding the download tasks
    … …  
    159152                tr("<html>Autostart ''Download from OSM'' dialog every time JOSM is started.<br>" +
    160153                        "You can open it manually from File menu or toolbar.</html>"));
    161         cbStartup.addActionListener(new ActionListener() {
    162             @Override
    163             public void actionPerformed(ActionEvent e) {
    164                  Main.pref.put("download.autorun", cbStartup.isSelected());
    165             }
    166         });
     154        cbStartup.addActionListener(e -> Main.pref.put("download.autorun", cbStartup.isSelected()));
    167155
    168156        pnl.add(cbNewLayer, GBC.std().anchor(GBC.WEST).insets(5, 5, 5, 5));

  • trunk/src/org/openstreetmap/josm/gui/download/DownloadObjectDialog.java

    r10378 r10611  
    55
    66import java.awt.Component;
    7 import java.awt.event.ItemEvent;
    8 import java.awt.event.ItemListener;
    97import java.awt.event.WindowEvent;
    108import java.util.Arrays;
    … …  
    7068        fullRel.setSelected(Main.pref.getBoolean("downloadprimitive.full", true));
    7169
    72         cbType.addItemListener(new ItemListener() {
    73             @Override
    74             public void itemStateChanged(ItemEvent e) {
    75                 referrers.setText(cbType.getType() == OsmPrimitiveType.NODE
    76                         ? tr("Download referrers (parent relations and ways)")
    77                         : tr("Download referrers (parent relations)"));
    78             }
    79         });
     70        cbType.addItemListener(e -> referrers.setText(cbType.getType() == OsmPrimitiveType.NODE
     71                ? tr("Download referrers (parent relations and ways)")
     72                : tr("Download referrers (parent relations)")));
    8073
    8174        return Arrays.<Component>asList(referrers, fullRel, newLayer);

  • trunk/src/org/openstreetmap/josm/gui/download/PlaceSelection.java

    r10217 r10611  
    384384                if (!canceled) {
    385385                    // Nominatim sometimes returns garbage, see #5934, #10643
    386                     Main.warn(tr("Error occured with query ''{0}'': ''{1}''", urlString, e.getMessage()));
    387                     GuiHelper.runInEDTAndWait(new Runnable() {
    388                         @Override
    389                         public void run() {
    390                             HelpAwareOptionPane.showOptionDialog(
    391                                     Main.parent,
    392                                     tr("Name server returned invalid data. Please try again."),
    393                                     tr("Bad response"),
    394                                     JOptionPane.WARNING_MESSAGE, null
    395                             );
    396                         }
    397                     });
     386                    Main.warn(e, tr("Error occured with query ''{0}'': ''{1}''", urlString, e.getMessage()));
     387                    GuiHelper.runInEDTAndWait(() -> HelpAwareOptionPane.showOptionDialog(
     388                            Main.parent,
     389                            tr("Name server returned invalid data. Please try again."),
     390                            tr("Bad response"),
     391                            JOptionPane.WARNING_MESSAGE, null
     392                    ));
    398393                }
    399394            } catch (IOException | ParserConfigurationException e) {

  • trunk/src/org/openstreetmap/josm/gui/help/HelpBrowser.java

    r10212 r10611  
    114114    public static void setUrlForHelpTopic(final String helpTopic) {
    115115        final HelpBrowser browser = getInstance();
    116         Runnable r = new Runnable() {
    117             @Override
    118             public void run() {
    119                 browser.openHelpTopic(helpTopic);
    120                 browser.setVisible(true);
    121                 browser.toFront();
    122             }
    123         };
    124         SwingUtilities.invokeLater(r);
     116        SwingUtilities.invokeLater(() -> {
     117            browser.openHelpTopic(helpTopic);
     118            browser.setVisible(true);
     119            browser.toFront();
     120        });
    125121    }
    126122

  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowser.java

    r10179 r10611  
    1111import javax.swing.JSplitPane;
    1212import javax.swing.JTabbedPane;
    13 import javax.swing.event.ChangeEvent;
    14 import javax.swing.event.ChangeListener;
    1513
    1614import org.openstreetmap.josm.data.osm.OsmPrimitive;
    … …  
    8078        pnl.add(tpViewers, BorderLayout.CENTER);
    8179
    82         tpViewers.addChangeListener(new ChangeListener() {
    83             @Override
    84             public void stateChanged(ChangeEvent e) {
    85                 if (tpViewers.getSelectedComponent() == coordinateInfoViewer) {
    86                     // while building the component size is not yet known, thus panning does not give reasonable results
    87                     coordinateInfoViewer.setDisplayToFitMapMarkers();
    88                 }
     80        tpViewers.addChangeListener(e -> {
     81            if (tpViewers.getSelectedComponent() == coordinateInfoViewer) {
     82                // while building the component size is not yet known, thus panning does not give reasonable results
     83                coordinateInfoViewer.setDisplayToFitMapMarkers();
    8984            }
    9085        });

  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserDialogManager.java

    r10345 r10611  
    196196        }
    197197
    198         Runnable r = new Runnable() {
    199 
    200             @Override
    201             public void run() {
    202                 try {
    203                     for (PrimitiveId p : notNewPrimitives) {
    204                         final History h = HistoryDataSet.getInstance().getHistory(p);
    205                         if (h == null) {
    206                             continue;
    207                         }
    208                         SwingUtilities.invokeLater(new Runnable() {
    209                             @Override
    210                             public void run() {
    211                                 show(h);
    212                             }
    213                         });
     198        Runnable r = () -> {
     199            try {
     200                for (PrimitiveId p : notNewPrimitives) {
     201                    final History h = HistoryDataSet.getInstance().getHistory(p);
     202                    if (h == null) {
     203                        continue;
    214204                    }
    215                 } catch (final RuntimeException e) {
    216                     BugReportExceptionHandler.handleException(e);
     205                    SwingUtilities.invokeLater(() -> show(h));
    217206                }
     207            } catch (final RuntimeException e) {
     208                BugReportExceptionHandler.handleException(e);
    218209            }
    219210        };
    … …  
    237228    };
    238229
    239     private final Predicate<PrimitiveId> notNewPredicate = new Predicate<PrimitiveId>() {
    240 
    241         @Override
    242         public boolean evaluate(PrimitiveId p) {
    243             return !p.isNew();
    244         }
    245     };
     230    private final Predicate<PrimitiveId> notNewPredicate = p -> !p.isNew();
    246231}

  • trunk/src/org/openstreetmap/josm/gui/history/NodeListViewer.java

    r10453 r10611  
    298298                Main.worker.submit(new HistoryLoadTask().add(primitiveId));
    299299            }
    300             Runnable r = new Runnable() {
    301                 @Override
    302                 public void run() {
    303                     final History h = HistoryDataSet.getInstance().getHistory(primitiveId);
    304                     if (h == null)
    305                         return;
    306                     GuiHelper.runInEDT(new Runnable() {
    307                         @Override public void run() {
    308                             HistoryBrowserDialogManager.getInstance().show(h);
    309                         }
    310                     });
    311                 }
    312             };
    313             Main.worker.submit(r);
     300            Main.worker.submit(() -> {
     301                final History h = HistoryDataSet.getInstance().getHistory(primitiveId);
     302                if (h == null)
     303                    return;
     304                GuiHelper.runInEDT(() -> HistoryBrowserDialogManager.getInstance().show(h));
     305            });
    314306        }
    315307

  • trunk/src/org/openstreetmap/josm/gui/history/VersionTable.java

    r10210 r10611  
    2525import javax.swing.event.ChangeEvent;
    2626import javax.swing.event.ChangeListener;
    27 import javax.swing.event.TableModelEvent;
    28 import javax.swing.event.TableModelListener;
    2927import javax.swing.table.TableCellRenderer;
    3028
    … …  
    9391            }
    9492        });
    95         getModel().addTableModelListener(new TableModelListener() {
    96             @Override
    97             public void tableChanged(TableModelEvent e) {
    98                 adjustColumnWidth(VersionTable.this, 0, 0);
    99                 adjustColumnWidth(VersionTable.this, 1, -8);
    100                 adjustColumnWidth(VersionTable.this, 2, -8);
    101                 adjustColumnWidth(VersionTable.this, 3, 0);
    102                 adjustColumnWidth(VersionTable.this, 4, 0);
    103             }
     93        getModel().addTableModelListener(e -> {
     94            adjustColumnWidth(VersionTable.this, 0, 0);
     95            adjustColumnWidth(VersionTable.this, 1, -8);
     96            adjustColumnWidth(VersionTable.this, 2, -8);
     97            adjustColumnWidth(VersionTable.this, 3, 0);
     98            adjustColumnWidth(VersionTable.this, 4, 0);
    10499        });
    105100    }

  • trunk/src/org/openstreetmap/josm/gui/io/AbstractPrimitiveTask.java

    r10212 r10611  
    184184            return;
    185185        }
    186         GuiHelper.runInEDTAndWait(new Runnable() {
    187             @Override
    188             public void run() {
    189                 layer.mergeFrom(ds);
    190                 if (zoom && Main.map != null)
    191                     AutoScaleAction.zoomTo(ds.allPrimitives());
    192                 layer.onPostDownloadFromServer();
    193             }
     186        GuiHelper.runInEDTAndWait(() -> {
     187            layer.mergeFrom(ds);
     188            if (zoom && Main.map != null)
     189                AutoScaleAction.zoomTo(ds.allPrimitives());
     190            layer.onPostDownloadFromServer();
    194191        });
    195192    }

  • trunk/src/org/openstreetmap/josm/gui/io/ActionFlagsTableCell.java

    r10305 r10611  
    4040    private final transient CellEditorSupport cellEditorSupport = new CellEditorSupport(this);
    4141
    42     private final transient ActionListener al = new ActionListener() {
    43         @Override
    44         public void actionPerformed(ActionEvent e) {
    45             cellEditorSupport.fireEditingStopped();
    46         }
    47     };
     42    private final transient ActionListener al = e -> cellEditorSupport.fireEditingStopped();
    4843
    4944    /**

  • trunk/src/org/openstreetmap/josm/gui/io/BasicUploadSettingsPanel.java

    r10210 r10611  
    2424import javax.swing.event.ChangeListener;
    2525import javax.swing.event.HyperlinkEvent;
    26 import javax.swing.event.HyperlinkListener;
    2726
    2827import org.openstreetmap.josm.Main;
    … …  
    7069        JEditorPane sourceLabel = new JMultilineLabel("<html><b>" + tr("Specify the data source for the changes")
    7170                + "</b> (<a href=\"urn:changeset-source\">" + tr("obtain from current layers") + "</a>)<b>:</b>");
    72         sourceLabel.addHyperlinkListener(new HyperlinkListener() {
    73             @Override
    74             public void hyperlinkUpdate(HyperlinkEvent e) {
    75                 if (HyperlinkEvent.EventType.ACTIVATED.equals(e.getEventType())) {
    76                     final String source = Main.map.mapView.getLayerInformationForSourceTag();
    77                     hcbUploadSource.setText(Utils.shortenString(source, Changeset.MAX_CHANGESET_TAG_LENGTH));
    78                     // Fix #9965
    79                     changesetSourceModel.setComment(hcbUploadSource.getText());
    80                 }
     71        sourceLabel.addHyperlinkListener(e -> {
     72            if (HyperlinkEvent.EventType.ACTIVATED.equals(e.getEventType())) {
     73                final String source = Main.map.mapView.getLayerInformationForSourceTag();
     74                hcbUploadSource.setText(Utils.shortenString(source, Changeset.MAX_CHANGESET_TAG_LENGTH));
     75                // Fix #9965
     76                changesetSourceModel.setComment(hcbUploadSource.getText());
    8177            }
    8278        });

  • trunk/src/org/openstreetmap/josm/gui/io/CloseChangesetTask.java

    r10212 r10611  
    5858            ExceptionDialogUtil.explainException(lastException);
    5959        }
    60         SwingUtilities.invokeLater(
    61                 new Runnable() {
    62                     @Override
    63                     public void run() {
    64                         ChangesetCache.getInstance().update(closedChangesets);
    65                     }
    66                 }
    67         );
     60        SwingUtilities.invokeLater(() -> ChangesetCache.getInstance().update(closedChangesets));
    6861    }
    6962

  • trunk/src/org/openstreetmap/josm/gui/io/DownloadOpenChangesetsTask.java

    r10212 r10611  
    8585            return;
    8686        }
    87         SwingUtilities.invokeLater(
    88                 new Runnable() {
    89                     @Override public void run() {
    90                         ChangesetCache.getInstance().update(changesets);
    91                     }
    92                 }
    93         );
     87        SwingUtilities.invokeLater(() -> ChangesetCache.getInstance().update(changesets));
    9488    }
    9589
    9690    /**
    97      * Refreshes the user info from the server. This is necessary if we don't know
    98      * the users id yet.
    99      *
     91     * Refreshes the user info from the server. This is necessary if we don't know the users id yet.
    10092     */
    10193    protected void refreshUserIdentity() {

  • trunk/src/org/openstreetmap/josm/gui/io/DownloadPrimitivesWithReferrersTask.java

    r10446 r10611  
    138138        final Set<PrimitiveId> errs = mainTask.getMissingPrimitives();
    139139        if (errs != null && !errs.isEmpty())
    140             GuiHelper.runInEDTAndWait(new Runnable() {
    141                 @Override
    142                 public void run() {
    143                     reportProblemDialog(errs,
    144                             trn("Object could not be downloaded", "Some objects could not be downloaded", errs.size()),
    145                             trn("One object could not be downloaded.<br>",
    146                                     "{0} objects could not be downloaded.<br>",
    147                                     errs.size(),
    148                                     errs.size())
    149                                     + tr("The server replied with response code 404.<br>"
    150                                          + "This usually means, the server does not know an object with the requested id."),
    151                             tr("missing objects:"),
    152                             JOptionPane.ERROR_MESSAGE
    153                             ).showDialog();
    154                 }
    155             });
     140            GuiHelper.runInEDTAndWait(() -> reportProblemDialog(errs,
     141                    trn("Object could not be downloaded", "Some objects could not be downloaded", errs.size()),
     142                    trn("One object could not be downloaded.<br>",
     143                            "{0} objects could not be downloaded.<br>",
     144                            errs.size(),
     145                            errs.size())
     146                            + tr("The server replied with response code 404.<br>"
     147                                 + "This usually means, the server does not know an object with the requested id."),
     148                    tr("missing objects:"),
     149                    JOptionPane.ERROR_MESSAGE
     150                    ).showDialog());
    156151
    157152        // Warm about deleted primitives
    … …  
    165160        }
    166161        if (!del.isEmpty())
    167             GuiHelper.runInEDTAndWait(new Runnable() {
    168                 @Override
    169                 public void run() {
    170                     reportProblemDialog(del,
    171                             trn("Object deleted", "Objects deleted", del.size()),
    172                             trn(
    173                                 "One downloaded object is deleted.",
    174                                 "{0} downloaded objects are deleted.",
    175                                 del.size(),
    176                                 del.size()),
    177                             null,
    178                             JOptionPane.WARNING_MESSAGE
    179                     ).showDialog();
    180                 }
    181             });
     162            GuiHelper.runInEDTAndWait(() -> reportProblemDialog(del,
     163                    trn("Object deleted", "Objects deleted", del.size()),
     164                    trn(
     165                        "One downloaded object is deleted.",
     166                        "{0} downloaded objects are deleted.",
     167                        del.size(),
     168                        del.size()),
     169                    null,
     170                    JOptionPane.WARNING_MESSAGE
     171            ).showDialog());
    182172    }
    183173

  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

    r10428 r10611  
    579579        @Override
    580580        public void run() {
    581             GuiHelper.runInEDTAndWait(new Runnable() {
    582                 @Override
    583                 public void run() {
    584                     model.setMode(SaveLayersModel.Mode.UPLOADING_AND_SAVING);
    585                     List<SaveLayerInfo> toUpload = model.getLayersToUpload();
    586                     if (!toUpload.isEmpty()) {
    587                         uploadLayers(toUpload);
    588                     }
    589                     List<SaveLayerInfo> toSave = model.getLayersToSave();
    590                     if (!toSave.isEmpty()) {
    591                         saveLayers(toSave);
    592                     }
    593                     model.setMode(SaveLayersModel.Mode.EDITING_DATA);
    594                     if (model.hasUnsavedData()) {
    595                         warnBecauseOfUnsavedData();
    596                         model.setMode(Mode.EDITING_DATA);
    597                         if (canceled) {
    598                             setUserAction(UserAction.CANCEL);
    599                             closeDialog();
    600                         }
    601                     } else {
    602                         setUserAction(UserAction.PROCEED);
     581            GuiHelper.runInEDTAndWait(() -> {
     582                model.setMode(SaveLayersModel.Mode.UPLOADING_AND_SAVING);
     583                List<SaveLayerInfo> toUpload = model.getLayersToUpload();
     584                if (!toUpload.isEmpty()) {
     585                    uploadLayers(toUpload);
     586                }
     587                List<SaveLayerInfo> toSave = model.getLayersToSave();
     588                if (!toSave.isEmpty()) {
     589                    saveLayers(toSave);
     590                }
     591                model.setMode(SaveLayersModel.Mode.EDITING_DATA);
     592                if (model.hasUnsavedData()) {
     593                    warnBecauseOfUnsavedData();
     594                    model.setMode(Mode.EDITING_DATA);
     595                    if (canceled) {
     596                        setUserAction(UserAction.CANCEL);
    603597                        closeDialog();
    604598                    }
     599                } else {
     600                    setUserAction(UserAction.PROCEED);
     601                    closeDialog();
    605602                }
    606603            });

  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersModel.java

    r10217 r10611  
    77import java.util.ArrayList;
    88import java.util.Collections;
    9 import java.util.Comparator;
    109import java.util.List;
    1110
    … …  
    7271            layerInfo.add(new SaveLayerInfo(layer));
    7372        }
    74         Collections.sort(
    75                 layerInfo,
    76                 new Comparator<SaveLayerInfo>() {
    77                     @Override
    78                     public int compare(SaveLayerInfo o1, SaveLayerInfo o2) {
    79                         return o1.compareTo(o2);
    80                     }
    81                 }
    82         );
     73        Collections.sort(layerInfo, (o1, o2) -> o1.compareTo(o2));
    8374        fireTableDataChanged();
    8475    }

  • trunk/src/org/openstreetmap/josm/gui/io/UploadPrimitivesTask.java

    r10378 r10611  
    219219        // we always clean up the data, even in case of errors. It's possible the data was
    220220        // partially uploaded. Better run on EDT.
    221         //
    222         Runnable r = new Runnable() {
    223             @Override
    224             public void run() {
    225                 layer.cleanupAfterUpload(processedPrimitives);
    226                 layer.onPostUploadToServer();
    227                 ChangesetCache.getInstance().update(changeset);
    228             }
     221        Runnable r = () -> {
     222            layer.cleanupAfterUpload(processedPrimitives);
     223            layer.onPostUploadToServer();
     224            ChangesetCache.getInstance().update(changeset);
    229225        };
    230226
    … …  
    320316        // - to the Upload Dialog
    321317        // - to map editing
    322         GuiHelper.runInEDT(new Runnable() {
    323             @Override
    324             public void run() {
    325                 // if the changeset is still open after this upload we want it to
    326                 // be selected on the next upload
    327                 //
    328                 ChangesetCache.getInstance().update(changeset);
    329                 if (changeset != null && changeset.isOpen()) {
    330                     UploadDialog.getUploadDialog().setSelectedChangesetForNextUpload(changeset);
    331                 }
    332                 if (uploadCanceled) return;
    333                 if (lastException == null) {
    334                     new Notification(
    335                             "<h3>" + tr("Upload successful!") + "</h3>")
    336                             .setIcon(ImageProvider.get("misc", "check_large"))
    337                             .show();
     318        GuiHelper.runInEDT(() -> {
     319            // if the changeset is still open after this upload we want it to be selected on the next upload
     320            ChangesetCache.getInstance().update(changeset);
     321            if (changeset != null && changeset.isOpen()) {
     322                UploadDialog.getUploadDialog().setSelectedChangesetForNextUpload(changeset);
     323            }
     324            if (uploadCanceled) return;
     325            if (lastException == null) {
     326                new Notification(
     327                        "<h3>" + tr("Upload successful!") + "</h3>")
     328                        .setIcon(ImageProvider.get("misc", "check_large"))
     329                        .show();
     330                return;
     331            }
     332            if (lastException instanceof ChangesetClosedException) {
     333                ChangesetClosedException e = (ChangesetClosedException) lastException;
     334                if (e.getSource().equals(ChangesetClosedException.Source.UPDATE_CHANGESET)) {
     335                    handleFailedUpload(lastException);
    338336                    return;
    339337                }
    340                 if (lastException instanceof ChangesetClosedException) {
    341                     ChangesetClosedException e = (ChangesetClosedException) lastException;
    342                     if (e.getSource().equals(ChangesetClosedException.Source.UPDATE_CHANGESET)) {
    343                         handleFailedUpload(lastException);
    344                         return;
    345                     }
    346                     if (strategy.getPolicy() == null)
    347                         /* do nothing if unknown policy */
    348                         return;
    349                     if (e.getSource().equals(ChangesetClosedException.Source.UPLOAD_DATA)) {
    350                         switch(strategy.getPolicy()) {
    351                         case ABORT:
    352                             break; /* do nothing - we return to map editing */
    353                         case AUTOMATICALLY_OPEN_NEW_CHANGESETS:
    354                             break; /* do nothing - we return to map editing */
    355                         case FILL_ONE_CHANGESET_AND_RETURN_TO_UPLOAD_DIALOG:
    356                             // return to the upload dialog
    357                             //
    358                             toUpload.removeProcessed(processedPrimitives);
    359                             UploadDialog.getUploadDialog().setUploadedPrimitives(toUpload);
    360                             UploadDialog.getUploadDialog().setVisible(true);
    361                             break;
    362                         }
    363                     } else {
    364                         handleFailedUpload(lastException);
     338                if (strategy.getPolicy() == null)
     339                    /* do nothing if unknown policy */
     340                    return;
     341                if (e.getSource().equals(ChangesetClosedException.Source.UPLOAD_DATA)) {
     342                    switch(strategy.getPolicy()) {
     343                    case ABORT:
     344                        break; /* do nothing - we return to map editing */
     345                    case AUTOMATICALLY_OPEN_NEW_CHANGESETS:
     346                        break; /* do nothing - we return to map editing */
     347                    case FILL_ONE_CHANGESET_AND_RETURN_TO_UPLOAD_DIALOG:
     348                        // return to the upload dialog
     349                        //
     350                        toUpload.removeProcessed(processedPrimitives);
     351                        UploadDialog.getUploadDialog().setUploadedPrimitives(toUpload);
     352                        UploadDialog.getUploadDialog().setVisible(true);
     353                        break;
    365354                    }
    366355                } else {
    367356                    handleFailedUpload(lastException);
    368357                }
     358            } else {
     359                handleFailedUpload(lastException);
    369360            }
    370361        });

  • trunk/src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

    r10596 r10611  
    18801880            double bufferX, double bufferY) {
    18811881        PrecacheTask precacheTask = new PrecacheTask(progressMonitor);
    1882         final Set<Tile> requestedTiles = new ConcurrentSkipListSet<>(new Comparator<Tile>() {
    1883             @Override
    1884             public int compare(Tile o1, Tile o2) {
    1885                 return String.CASE_INSENSITIVE_ORDER.compare(o1.getKey(), o2.getKey());
    1886             }
    1887         });
     1882        final Set<Tile> requestedTiles = new ConcurrentSkipListSet<>(
     1883                (o1, o2) -> String.CASE_INSENSITIVE_ORDER.compare(o1.getKey(), o2.getKey()));
    18881884        for (LatLon point: points) {
    18891885

  • trunk/src/org/openstreetmap/josm/gui/layer/AlignImageryPanel.java

    r10000 r10611  
    77import java.awt.Font;
    88import java.awt.GridBagLayout;
    9 import java.awt.event.ActionEvent;
    10 import java.awt.event.ActionListener;
    119
    1210import javax.swing.JButton;
    … …  
    5553        closeButton.setBorderPainted(false);
    5654        closeButton.setToolTipText(tr("Hide this message and never show it again"));
    57         closeButton.addActionListener(new ActionListener() {
    58             @Override
    59             public void actionPerformed(ActionEvent e) {
    60                 if (Main.isDisplayingMapView()) {
    61                     Main.map.removeTopPanel(AlignImageryPanel.class);
    62                     if (doNotShowAgain.isSelected()) {
    63                         showAgain.put(Boolean.FALSE);
    64                     }
     55        closeButton.addActionListener(e -> {
     56            if (Main.isDisplayingMapView()) {
     57                Main.map.removeTopPanel(AlignImageryPanel.class);
     58                if (doNotShowAgain.isSelected()) {
     59                    showAgain.put(Boolean.FALSE);
    6560                }
    6661            }

  • trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

    r10364 r10611  
    183183        final JScrollPane sp = new JScrollPane(new HtmlPanel(info.toString()));
    184184        sp.setPreferredSize(new Dimension(sp.getPreferredSize().width+20, 370));
    185         SwingUtilities.invokeLater(new Runnable() {
    186             @Override
    187             public void run() {
    188                 sp.getVerticalScrollBar().setValue(0);
    189             }
    190         });
     185        SwingUtilities.invokeLater(() -> sp.getVerticalScrollBar().setValue(0));
    191186        return sp;
    192187    }

  • trunk/src/org/openstreetmap/josm/gui/layer/ImageryLayer.java

    r10571 r10611  
    301301     */
    302302    public static ImageProcessor createImageProcessor(final BufferedImageOp op, final boolean inPlace) {
    303         return new ImageProcessor() {
    304             @Override
    305             public BufferedImage process(BufferedImage image) {
    306                 return op.filter(image, inPlace ? image : null);
    307             }
    308         };
     303        return image -> op.filter(image, inPlace ? image : null);
    309304    }
    310305

  • trunk/src/org/openstreetmap/josm/gui/layer/Layer.java

    r10600 r10611  
    516516
    517517            // run later to not block loading the UI.
    518             SwingUtilities.invokeLater(new Runnable() {
    519                 @Override
    520                 public void run() {
    521                     JOptionPane.showMessageDialog(Main.parent,
    522                             message,
    523                             tr("Warning"),
    524                             JOptionPane.WARNING_MESSAGE);
    525                 }
    526             });
     518            SwingUtilities.invokeLater(() -> JOptionPane.showMessageDialog(Main.parent,
     519                    message,
     520                    tr("Warning"),
     521                    JOptionPane.WARNING_MESSAGE));
    527522        }
    528523    }

  • trunk/src/org/openstreetmap/josm/gui/layer/LayerManager.java

    r10598 r10611  
    178178        // we force this on to the EDT Thread to make events fire from there.
    179179        // The synchronization lock needs to be held by the EDT.
    180         GuiHelper.runInEDTAndWaitWithException(new Runnable() {
    181             @Override
    182             public void run() {
    183                 realAddLayer(layer);
    184             }
    185         });
     180        GuiHelper.runInEDTAndWaitWithException(() -> realAddLayer(layer));
    186181    }
    187182
    … …  
    208203        // we force this on to the EDT Thread to make events fire from there.
    209204        // The synchronization lock needs to be held by the EDT.
    210         GuiHelper.runInEDTAndWaitWithException(new Runnable() {
    211             @Override
    212             public void run() {
    213                 realRemoveLayer(layer);
    214             }
    215         });
     205        GuiHelper.runInEDTAndWaitWithException(() -> realRemoveLayer(layer));
    216206    }
    217207
    … …  
    247237        // we force this on to the EDT Thread to make events fire from there.
    248238        // The synchronization lock needs to be held by the EDT.
    249         GuiHelper.runInEDTAndWaitWithException(new Runnable() {
    250             @Override
    251             public void run() {
    252                 realMoveLayer(layer, position);
    253             }
    254         });
     239        GuiHelper.runInEDTAndWaitWithException(() -> realMoveLayer(layer, position));
    255240    }
    256241

  • trunk/src/org/openstreetmap/josm/gui/layer/MainLayerManager.java

    r10600 r10611  
    228228        // we force this on to the EDT Thread to make events fire from there.
    229229        // The synchronization lock needs to be held by the EDT.
    230         GuiHelper.runInEDTAndWaitWithException(new Runnable() {
    231             @Override
    232             public void run() {
    233                 realSetActiveLayer(layer);
    234             }
    235         });
     230        GuiHelper.runInEDTAndWaitWithException(() -> realSetActiveLayer(layer));
    236231    }
    237232

  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r10600 r10611  
    3030import java.util.Map;
    3131import java.util.Set;
    32 import java.util.concurrent.Callable;
    3332import java.util.concurrent.CopyOnWriteArrayList;
    3433import java.util.regex.Pattern;
    … …  
    994993    @Override
    995994    public boolean checkSaveConditions() {
    996         if (isDataSetEmpty() && 1 != GuiHelper.runInEDTAndWaitAndReturn(new Callable<Integer>() {
    997             @Override
    998             public Integer call() {
    999                 if (GraphicsEnvironment.isHeadless()) {
    1000                     return 2;
    1001                 }
    1002                 ExtendedDialog dialog = new ExtendedDialog(
    1003                         Main.parent,
    1004                         tr("Empty document"),
    1005                         new String[] {tr("Save anyway"), tr("Cancel")}
    1006                 );
    1007                 dialog.setContent(tr("The document contains no data."));
    1008                 dialog.setButtonIcons(new String[] {"save", "cancel"});
    1009                 return dialog.showDialog().getValue();
    1010             }
     995        if (isDataSetEmpty() && 1 != GuiHelper.runInEDTAndWaitAndReturn(() -> {
     996            if (GraphicsEnvironment.isHeadless()) {
     997                return 2;
     998            }
     999            ExtendedDialog dialog = new ExtendedDialog(
     1000                    Main.parent,
     1001                    tr("Empty document"),
     1002                    new String[] {tr("Save anyway"), tr("Cancel")}
     1003            );
     1004            dialog.setContent(tr("The document contains no data."));
     1005            dialog.setButtonIcons(new String[] {"save", "cancel"});
     1006            return dialog.showDialog().getValue();
    10111007        })) {
    10121008            return false;
    … …  
    10141010
    10151011        ConflictCollection conflictsCol = getConflicts();
    1016         if (conflictsCol != null && !conflictsCol.isEmpty() && 1 != GuiHelper.runInEDTAndWaitAndReturn(new Callable<Integer>() {
    1017             @Override
    1018             public Integer call() {
    1019                 ExtendedDialog dialog = new ExtendedDialog(
    1020                         Main.parent,
    1021                         /* I18N: Display title of the window showing conflicts */
    1022                         tr("Conflicts"),
    1023                         new String[] {tr("Reject Conflicts and Save"), tr("Cancel")}
    1024                 );
    1025                 dialog.setContent(
    1026                         tr("There are unresolved conflicts. Conflicts will not be saved and handled as if you rejected all. Continue?"));
    1027                 dialog.setButtonIcons(new String[] {"save", "cancel"});
    1028                 return dialog.showDialog().getValue();
    1029             }
     1012        if (conflictsCol != null && !conflictsCol.isEmpty() && 1 != GuiHelper.runInEDTAndWaitAndReturn(() -> {
     1013            ExtendedDialog dialog = new ExtendedDialog(
     1014                    Main.parent,
     1015                    /* I18N: Display title of the window showing conflicts */
     1016                    tr("Conflicts"),
     1017                    new String[] {tr("Reject Conflicts and Save"), tr("Cancel")}
     1018            );
     1019            dialog.setContent(
     1020                    tr("There are unresolved conflicts. Conflicts will not be saved and handled as if you rejected all. Continue?"));
     1021            dialog.setButtonIcons(new String[] {"save", "cancel"});
     1022            return dialog.showDialog().getValue();
    10301023        })) {
    10311024            return false;

  • trunk/src/org/openstreetmap/josm/gui/layer/TMSLayer.java

    r10184 r10611  
    7373    @Override
    7474    protected TMSTileSource getTileSource(ImageryInfo info) {
    75         return getTileSourceStatic(info, new Runnable() {
    76             @Override
    77             public void run() {
    78                 Main.debug("Attribution loaded, running loadAllErrorTiles");
    79                 TMSLayer.this.loadAllErrorTiles(false);
    80             }
     75        return getTileSourceStatic(info, () -> {
     76            Main.debug("Attribution loaded, running loadAllErrorTiles");
     77            TMSLayer.this.loadAllErrorTiles(false);
    8178        });
    8279    }

  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImages.java

    r10420 r10611  
    3030import java.util.Collection;
    3131import java.util.Collections;
    32 import java.util.Comparator;
    3332import java.util.Date;
    3433import java.util.Dictionary;
    … …  
    6059import javax.swing.event.DocumentEvent;
    6160import javax.swing.event.DocumentListener;
    62 import javax.swing.event.ListSelectionEvent;
    63 import javax.swing.event.ListSelectionListener;
    6461import javax.swing.filechooser.FileFilter;
    6562
    … …  
    460457            });
    461458            imgList.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    462             imgList.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
    463 
    464                 @Override
    465                 public void valueChanged(ListSelectionEvent arg0) {
    466                     int index = imgList.getSelectedIndex();
    467                     Integer orientation = ExifReader.readOrientation(yLayer.data.get(index).getFile());
    468                     imgDisp.setImage(yLayer.data.get(index).getFile(), orientation);
    469                     Date date = yLayer.data.get(index).getExifTime();
    470                     if (date != null) {
    471                         DateFormat df = DateUtils.getDateTimeFormat(DateFormat.SHORT, DateFormat.MEDIUM);
    472                         lbExifTime.setText(df.format(date));
    473                         tfGpsTime.setText(df.format(date));
    474                         tfGpsTime.setCaretPosition(tfGpsTime.getText().length());
    475                         tfGpsTime.setEnabled(true);
    476                         tfGpsTime.requestFocus();
    477                     } else {
    478                         lbExifTime.setText(tr("No date"));
    479                         tfGpsTime.setText("");
    480                         tfGpsTime.setEnabled(false);
    481                     }
     459            imgList.getSelectionModel().addListSelectionListener(evt -> {
     460                int index = imgList.getSelectedIndex();
     461                Integer orientation = ExifReader.readOrientation(yLayer.data.get(index).getFile());
     462                imgDisp.setImage(yLayer.data.get(index).getFile(), orientation);
     463                Date date = yLayer.data.get(index).getExifTime();
     464                if (date != null) {
     465                    DateFormat df = DateUtils.getDateTimeFormat(DateFormat.SHORT, DateFormat.MEDIUM);
     466                    lbExifTime.setText(df.format(date));
     467                    tfGpsTime.setText(df.format(date));
     468                    tfGpsTime.setCaretPosition(tfGpsTime.getText().length());
     469                    tfGpsTime.setEnabled(true);
     470                    tfGpsTime.requestFocus();
     471                } else {
     472                    lbExifTime.setText(tr("No date"));
     473                    tfGpsTime.setText("");
     474                    tfGpsTime.setEnabled(false);
    482475                }
    483476            });
    … …  
    485478
    486479            JButton openButton = new JButton(tr("Open another photo"));
    487             openButton.addActionListener(new ActionListener() {
    488 
    489                 @Override
    490                 public void actionPerformed(ActionEvent ae) {
    491                     AbstractFileChooser fc = DiskAccessAction.createAndOpenFileChooser(true, false, null,
    492                             JpgImporter.FILE_FILTER_WITH_FOLDERS, JFileChooser.FILES_ONLY, "geoimage.lastdirectory");
    493                     if (fc == null)
    494                         return;
    495                     File sel = fc.getSelectedFile();
    496 
    497                     Integer orientation = ExifReader.readOrientation(sel);
    498                     imgDisp.setImage(sel, orientation);
    499 
    500                     Date date = ExifReader.readTime(sel);
    501                     if (date != null) {
    502                         lbExifTime.setText(DateUtils.getDateTimeFormat(DateFormat.SHORT, DateFormat.MEDIUM).format(date));
    503                         tfGpsTime.setText(DateUtils.getDateFormat(DateFormat.SHORT).format(date)+' ');
    504                         tfGpsTime.setEnabled(true);
    505                     } else {
    506                         lbExifTime.setText(tr("No date"));
    507                         tfGpsTime.setText("");
    508                         tfGpsTime.setEnabled(false);
    509                     }
     480            openButton.addActionListener(ae -> {
     481                AbstractFileChooser fc = DiskAccessAction.createAndOpenFileChooser(true, false, null,
     482                        JpgImporter.FILE_FILTER_WITH_FOLDERS, JFileChooser.FILES_ONLY, "geoimage.lastdirectory");
     483                if (fc == null)
     484                    return;
     485                File sel = fc.getSelectedFile();
     486
     487                Integer orientation = ExifReader.readOrientation(sel);
     488                imgDisp.setImage(sel, orientation);
     489
     490                Date date = ExifReader.readTime(sel);
     491                if (date != null) {
     492                    lbExifTime.setText(DateUtils.getDateTimeFormat(DateFormat.SHORT, DateFormat.MEDIUM).format(date));
     493                    tfGpsTime.setText(DateUtils.getDateFormat(DateFormat.SHORT).format(date)+' ');
     494                    tfGpsTime.setEnabled(true);
     495                } else {
     496                    lbExifTime.setText(tr("No date"));
     497                    tfGpsTime.setText("");
     498                    tfGpsTime.setEnabled(false);
    510499                }
    511500            });
    … …  
    10921081        }
    10931082
    1094         Collections.sort(dateImgLst, new Comparator<ImageEntry>() {
    1095             @Override
    1096             public int compare(ImageEntry arg0, ImageEntry arg1) {
    1097                 return arg0.getExifTime().compareTo(arg1.getExifTime());
    1098             }
    1099         });
     1083        Collections.sort(dateImgLst, (o1, o2) -> o1.getExifTime().compareTo(o2.getExifTime()));
    11001084
    11011085        return dateImgLst;

  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java

    r10604 r10611  
    6666import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
    6767import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
    68 import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
    69 import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
    7068import org.openstreetmap.josm.gui.util.GuiHelper;
    7169import org.openstreetmap.josm.io.JpgImporter;
    … …  
    431429
    432430        if (selected != null && !data.isEmpty()) {
    433             GuiHelper.runInEDTAndWait(new Runnable() {
    434                 @Override
    435                 public void run() {
    436                     for (int i = 0; i < data.size(); i++) {
    437                         if (selected.equals(data.get(i))) {
    438                             currentPhoto = i;
    439                             ImageViewerDialog.showImage(GeoImageLayer.this, data.get(i));
    440                             break;
    441                         }
     431            GuiHelper.runInEDTAndWait(() -> {
     432                for (int i = 0; i < data.size(); i++) {
     433                    if (selected.equals(data.get(i))) {
     434                        currentPhoto = i;
     435                        ImageViewerDialog.showImage(GeoImageLayer.this, data.get(i));
     436                        break;
    442437                    }
    443438                }
    … …  
    881876        };
    882877
    883         mapModeListener = new MapModeChangeListener() {
    884             @Override
    885             public void mapModeChange(MapMode oldMapMode, MapMode newMapMode) {
    886                 if (newMapMode == null || isSupportedMapMode(newMapMode)) {
    887                     Main.map.mapView.addMouseListener(mouseAdapter);
    888                 } else {
    889                     Main.map.mapView.removeMouseListener(mouseAdapter);
    890                 }
     878        mapModeListener = (oldMapMode, newMapMode) -> {
     879            if (newMapMode == null || isSupportedMapMode(newMapMode)) {
     880                Main.map.mapView.addMouseListener(mouseAdapter);
     881            } else {
     882                Main.map.mapView.removeMouseListener(mouseAdapter);
    891883            }
    892884        };
    … …  
    895887        mapModeListener.mapModeChange(null, Main.map.mapMode);
    896888
    897         Main.getLayerManager().addActiveLayerChangeListener(new ActiveLayerChangeListener() {
    898             @Override
    899             public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
    900                 if (Main.getLayerManager().getActiveLayer() == GeoImageLayer.this) {
    901                     // only in select mode it is possible to click the images
    902                     Main.map.selectSelectTool(false);
    903                 }
     889        Main.getLayerManager().addActiveLayerChangeListener(e -> {
     890            if (Main.getLayerManager().getActiveLayer() == GeoImageLayer.this) {
     891                // only in select mode it is possible to click the images
     892                Main.map.selectSelectTool(false);
    904893            }
    905894        });

  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java

    r9880 r10611  
    1010import java.awt.GridBagLayout;
    1111import java.awt.event.ActionEvent;
    12 import java.awt.event.ActionListener;
    1312import java.awt.event.MouseAdapter;
    1413import java.awt.event.MouseEvent;
    … …  
    2726import javax.swing.JToggleButton;
    2827import javax.swing.ListSelectionModel;
    29 import javax.swing.event.ListSelectionEvent;
    30 import javax.swing.event.ListSelectionListener;
    3128import javax.swing.table.DefaultTableModel;
    3229import javax.swing.table.TableCellRenderer;
    … …  
    205202    /** listens to selection changes in the table and redraws the map */
    206203    private void listenToSelectionChanges() {
    207         table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
    208             @Override
    209             public void valueChanged(ListSelectionEvent e) {
    210                 if (noUpdates || !(e.getSource() instanceof ListSelectionModel)) {
    211                     return;
    212                 }
    213                 updateVisibilityFromTable();
    214             }
     204        table.getSelectionModel().addListSelectionListener(e -> {
     205            if (noUpdates || !(e.getSource() instanceof ListSelectionModel)) {
     206                return;
     207            }
     208            updateVisibilityFromTable();
    215209        });
    216210    }
    … …  
    230224
    231225        dateFilter = new DateFilterPanel(layer, "gpx.traces", false);
    232         dateFilter.setFilterAppliedListener(new ActionListener() {
    233             @Override public void actionPerformed(ActionEvent e) {
    234                 noUpdates = true;
    235                 selectVisibleTracksInTable();
    236                 noUpdates = false;
    237                 Main.map.mapView.preferenceChanged(null);
    238                 Main.map.repaint(100);
    239             }
     226        dateFilter.setFilterAppliedListener(e -> {
     227            noUpdates = true;
     228            selectVisibleTracksInTable();
     229            noUpdates = false;
     230            Main.map.mapView.preferenceChanged(null);
     231            Main.map.repaint(100);
    240232        });
    241233        dateFilter.loadFromPrefs();

  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/DateFilterPanel.java

    r10378 r10611  
    66import java.awt.Component;
    77import java.awt.GridBagLayout;
    8 import java.awt.event.ActionEvent;
    98import java.awt.event.ActionListener;
    109import java.util.Date;
    … …  
    1413import javax.swing.JPanel;
    1514import javax.swing.Timer;
    16 import javax.swing.event.ChangeEvent;
    1715import javax.swing.event.ChangeListener;
    1816
    … …  
    7068    }
    7169
    72     private final transient ChangeListener changeListener = new ChangeListener() {
    73         @Override public void stateChanged(ChangeEvent e) {
    74             if (isEnabled()) applyFilterWithDelay();
    75         }
     70    private final transient ChangeListener changeListener = e -> {
     71        if (isEnabled()) applyFilterWithDelay();
    7672    };
    7773
    78     private final Timer t = new Timer(200, new ActionListener() {
    79         @Override public void actionPerformed(ActionEvent e) {
    80             applyFilter();
    81         }
    82     });
     74    private final Timer t = new Timer(200, e -> applyFilter());
    8375
    8476    /**

  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/DownloadAlongPanel.java

    r9917 r10611  
    1414import javax.swing.JSpinner;
    1515import javax.swing.SpinnerNumberModel;
    16 import javax.swing.event.ChangeEvent;
    1716import javax.swing.event.ChangeListener;
    1817
    … …  
    179178        };
    180179
    181         addChangeListener(new ChangeListener() {
    182             @Override public void stateChanged(ChangeEvent e) {
    183                 options[0].setEnabled(isDownloadOsmData() || isDownloadGpxData());
    184             }
    185         });
     180        addChangeListener(e -> options[0].setEnabled(isDownloadOsmData() || isDownloadGpxData()));
    186181
    187182        int ret = HelpAwareOptionPane.showOptionDialog(Main.parent, this, title,

  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ImportAudioAction.java

    r10436 r10611  
    1212import java.util.Collection;
    1313import java.util.Collections;
    14 import java.util.Comparator;
    1514
    1615import javax.swing.AbstractAction;
    … …  
    8988            // long as they don't overlap, that's fine)
    9089            if (sel.length > 1) {
    91                 Arrays.sort(sel, new Comparator<File>() {
    92                     @Override
    93                     public int compare(File a, File b) {
    94                         return a.lastModified() <= b.lastModified() ? -1 : 1;
    95                     }
    96                 });
     90                Arrays.sort(sel, (a, b) -> a.lastModified() <= b.lastModified() ? -1 : 1);
    9791            }
    9892            StringBuilder names = new StringBuilder();
    … …  
    284278        /* we must have got at least one waypoint now */
    285279
    286         Collections.sort((ArrayList<WayPoint>) waypoints, new Comparator<WayPoint>() {
    287             @Override
    288             public int compare(WayPoint a, WayPoint b) {
    289                 return a.time <= b.time ? -1 : 1;
    290             }
    291         });
     280        Collections.sort((ArrayList<WayPoint>) waypoints, (a, b) -> a.time <= b.time ? -1 : 1);
    292281
    293282        firstTime = -1.0; /* this time of the first waypoint, not first trackpoint */
    … …  
    299288            AudioMarker am = new AudioMarker(w.getCoor(), w, url, ml, w.time, offset);
    300289            /*
    301              * timeFromAudio intended for future use to shift markers of this type on
    302              * synchronization
     290             * timeFromAudio intended for future use to shift markers of this type on synchronization
    303291             */
    304292            if (w == wayPointFromTimeStamp) {

  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/ImageMarker.java

    r9779 r10611  
    77import java.awt.Image;
    88import java.awt.event.ActionEvent;
    9 import java.awt.event.ActionListener;
    109import java.net.URL;
    1110import java.util.Collections;
    … …  
    5554        p2.add(scale);
    5655        p.add(p2, BorderLayout.SOUTH);
    57         scale.addActionListener(new ActionListener() {
    58             @Override
    59             public void actionPerformed(ActionEvent ev) {
    60                 p.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
    61                 if (scale.getModel().isSelected()) {
    62                     ((JLabel) vp.getView()).setIcon(loadScaledImage(imageUrl, Math.max(vp.getWidth(), vp.getHeight())));
    63                 } else {
    64                     ((JLabel) vp.getView()).setIcon(new ImageIcon(imageUrl));
    65                 }
    66                 p.setCursor(Cursor.getDefaultCursor());
     56        scale.addActionListener(ev1 -> {
     57            p.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
     58            if (scale.getModel().isSelected()) {
     59                ((JLabel) vp.getView()).setIcon(loadScaledImage(imageUrl, Math.max(vp.getWidth(), vp.getHeight())));
     60            } else {
     61                ((JLabel) vp.getView()).setIcon(new ImageIcon(imageUrl));
    6762            }
     63            p.setCursor(Cursor.getDefaultCursor());
    6864        });
    6965        scale.setSelected(true);

  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/Marker.java

    r10173 r10611  
    183183    // Add one Marker specifying the default behaviour.
    184184    static {
    185         Marker.markerProducers.add(new MarkerProducers() {
    186             @Override
    187             public Collection<Marker> createMarkers(WayPoint wpt, File relativePath, MarkerLayer parentLayer, double time, double offset) {
    188                 String uri = null;
    189                 // cheapest way to check whether "link" object exists and is a non-empty collection of GpxLink objects...
    190                 Collection<GpxLink> links = wpt.<GpxLink>getCollection(GpxConstants.META_LINKS);
    191                 if (links != null) {
    192                     for (GpxLink oneLink : links) {
    193                         uri = oneLink.uri;
    194                         break;
     185        Marker.markerProducers.add((wpt, relativePath, parentLayer, time, offset) -> {
     186            String uri = null;
     187            // cheapest way to check whether "link" object exists and is a non-empty collection of GpxLink objects...
     188            Collection<GpxLink> links = wpt.<GpxLink>getCollection(GpxConstants.META_LINKS);
     189            if (links != null) {
     190                for (GpxLink oneLink : links) {
     191                    uri = oneLink.uri;
     192                    break;
     193                }
     194            }
     195
     196            URL url = uriToUrl(uri, relativePath);
     197
     198            String urlStr = url == null ? "" : url.toString();
     199            String symbolName = wpt.getString("symbol");
     200            if (symbolName == null) {
     201                symbolName = wpt.getString(GpxConstants.PT_SYM);
     202            }
     203            // text marker is returned in every case, see #10208
     204            final Marker marker = new Marker(wpt.getCoor(), wpt, symbolName, parentLayer, time, offset);
     205            if (url == null) {
     206                return Collections.singleton(marker);
     207            } else if (urlStr.endsWith(".wav")) {
     208                final AudioMarker audioMarker = new AudioMarker(wpt.getCoor(), wpt, url, parentLayer, time, offset);
     209                Extensions exts = (Extensions) wpt.get(GpxConstants.META_EXTENSIONS);
     210                if (exts != null && exts.containsKey("offset")) {
     211                    try {
     212                        audioMarker.syncOffset = Double.parseDouble(exts.get("sync-offset"));
     213                    } catch (NumberFormatException nfe) {
     214                        Main.warn(nfe);
    195215                    }
    196216                }
    197 
    198                 URL url = uriToUrl(uri, relativePath);
    199 
    200                 String urlStr = url == null ? "" : url.toString();
    201                 String symbolName = wpt.getString("symbol");
    202                 if (symbolName == null) {
    203                     symbolName = wpt.getString(GpxConstants.PT_SYM);
    204                 }
    205                 // text marker is returned in every case, see #10208
    206                 final Marker marker = new Marker(wpt.getCoor(), wpt, symbolName, parentLayer, time, offset);
    207                 if (url == null) {
    208                     return Collections.singleton(marker);
    209                 } else if (urlStr.endsWith(".wav")) {
    210                     final AudioMarker audioMarker = new AudioMarker(wpt.getCoor(), wpt, url, parentLayer, time, offset);
    211                     Extensions exts = (Extensions) wpt.get(GpxConstants.META_EXTENSIONS);
    212                     if (exts != null && exts.containsKey("offset")) {
    213                         try {
    214                             audioMarker.syncOffset = Double.parseDouble(exts.get("sync-offset"));
    215                         } catch (NumberFormatException nfe) {
    216                             Main.warn(nfe);
    217                         }
    218                     }
    219                     return Arrays.asList(marker, audioMarker);
    220                 } else if (urlStr.endsWith(".png") || urlStr.endsWith(".jpg") || urlStr.endsWith(".jpeg") || urlStr.endsWith(".gif")) {
    221                     return Arrays.asList(marker, new ImageMarker(wpt.getCoor(), url, parentLayer, time, offset));
    222                 } else {
    223                     return Arrays.asList(marker, new WebMarker(wpt.getCoor(), url, parentLayer, time, offset));
    224                 }
     217                return Arrays.asList(marker, audioMarker);
     218            } else if (urlStr.endsWith(".png") || urlStr.endsWith(".jpg") || urlStr.endsWith(".jpeg") || urlStr.endsWith(".gif")) {
     219                return Arrays.asList(marker, new ImageMarker(wpt.getCoor(), url, parentLayer, time, offset));
     220            } else {
     221                return Arrays.asList(marker, new WebMarker(wpt.getCoor(), url, parentLayer, time, offset));
    225222            }
    226223        });

  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

    r10458 r10611  
    2020import java.util.Collection;
    2121import java.util.Collections;
    22 import java.util.Comparator;
    2322import java.util.List;
    2423
    … …  
    235234        if (from instanceof MarkerLayer) {
    236235            data.addAll(((MarkerLayer) from).data);
    237             Collections.sort(data, new Comparator<Marker>() {
    238                 @Override
    239                 public int compare(Marker o1, Marker o2) {
    240                     return Double.compare(o1.time, o2.time);
    241                 }
    242             });
     236            Collections.sort(data, (o1, o2) -> Double.compare(o1.time, o2.time));
    243237        }
    244238    }

  • trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/PlayHeadMarker.java

    r10212 r10611  
    77import java.awt.Point;
    88import java.awt.Rectangle;
    9 import java.awt.event.ActionEvent;
    10 import java.awt.event.ActionListener;
    119import java.awt.event.MouseAdapter;
    1210import java.awt.event.MouseEvent;
    … …  
    290288        if (timer == null) {
    291289            animationInterval = Main.pref.getDouble("marker.audioanimationinterval", 1.0); //milliseconds
    292             timer = new Timer((int) (animationInterval * 1000.0), new ActionListener() {
    293                 @Override
    294                 public void actionPerformed(ActionEvent e) {
    295                     timerAction();
    296                 }
    297             });
     290            timer = new Timer((int) (animationInterval * 1000.0), e -> timerAction());
    298291            timer.setInitialDelay(0);
    299292        } else {

  • trunk/src/org/openstreetmap/josm/gui/mappaint/ElemStyles.java

    r10378 r10611  
    5959    public void clearCached() {
    6060        // run in EDT to make sure this isn't called during rendering run
    61         GuiHelper.runInEDT(new Runnable() {
    62             @Override
    63             public void run() {
    64                 cacheIdx++;
    65                 preferenceCache.clear();
    66             }
     61        GuiHelper.runInEDT(() -> {
     62            cacheIdx++;
     63            preferenceCache.clear();
    6764        });
    6865    }

  • trunk/src/org/openstreetmap/josm/gui/mappaint/MapPaintStyles.java

    r10567 r10611  
    365365        @Override
    366366        protected void finish() {
    367             SwingUtilities.invokeLater(new Runnable() {
    368                 @Override
    369                 public void run() {
    370                     fireMapPaintSylesUpdated();
    371                     styles.clearCached();
    372                     if (Main.isDisplayingMapView()) {
    373                         Main.map.mapView.preferenceChanged(null);
    374                         Main.map.mapView.repaint();
    375                     }
     367            SwingUtilities.invokeLater(() -> {
     368                fireMapPaintSylesUpdated();
     369                styles.clearCached();
     370                if (Main.isDisplayingMapView()) {
     371                    Main.map.mapView.preferenceChanged(null);
     372                    Main.map.mapView.repaint();
    376373                }
    377374            });

  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

    r10045 r10611  
    3939import org.openstreetmap.josm.tools.RightAndLefthandTraffic;
    4040import org.openstreetmap.josm.tools.Utils;
     41import org.openstreetmap.josm.tools.Utils.Function;
    4142
    4243/**
    … …  
    11271128
    11281129        public Float aggregateList(List<?> lst) {
    1129             final List<Float> floats = Utils.transform(lst, new Utils.Function<Object, Float>() {
    1130                 @Override
    1131                 public Float apply(Object x) {
    1132                     return Cascade.convertTo(x, float.class);
    1133                 }
    1134             });
     1130            final List<Float> floats = Utils.transform(lst, (Function<Object, Float>) x -> Cascade.convertTo(x, float.class));
    11351131            final Collection<Float> nonNullList = Utils.filter(floats, Predicates.not(Predicates.isNull()));
    11361132            return nonNullList.isEmpty() ? (Float) Float.NaN : computeMax ? Collections.max(nonNullList) : Collections.min(nonNullList);
    … …  
    11411137            List<?> l = Cascade.convertTo(args.get(0).evaluate(env), List.class);
    11421138            if (args.size() != 1 || l == null)
    1143                 l = Utils.transform(args, new Utils.Function<Expression, Object>() {
    1144                     @Override
    1145                     public Object apply(Expression x) {
    1146                         return x.evaluate(env);
    1147                     }
    1148                 });
     1139                l = Utils.transform(args, (Function<Expression, Object>) x -> x.evaluate(env));
    11491140            return aggregateList(l);
    11501141        }

  • trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/MapImage.java

    r10378 r10611  
    9999                .setHeight(height)
    100100                .setOptional(true)
    101                 .getInBackground(new ImageCallback() {
    102                     @Override
    103                     public void finished(ImageIcon result) {
    104                         synchronized (MapImage.this) {
    105                             if (result == null) {
    106                                 source.logWarning(tr("Failed to locate image ''{0}''", name));
    107                                 ImageIcon noIcon = MapPaintStyles.getNoIcon_Icon(source);
    108                                 img = noIcon == null ? null : (BufferedImage) noIcon.getImage();
    109                             } else {
    110                                 img = (BufferedImage) rescale(result.getImage());
    111                             }
    112                             if (temporary) {
    113                                 disabledImgCache = null;
    114                                 Main.map.mapView.preferenceChanged(null); // otherwise repaint is ignored, because layer hasn't changed
    115                                 Main.map.mapView.repaint();
    116                             }
    117                             temporary = false;
     101                .getInBackground((ImageCallback) result -> {
     102                    synchronized (MapImage.this) {
     103                        if (result == null) {
     104                            source.logWarning(tr("Failed to locate image ''{0}''", name));
     105                            ImageIcon noIcon = MapPaintStyles.getNoIcon_Icon(source);
     106                            img = noIcon == null ? null : (BufferedImage) noIcon.getImage();
     107                        } else {
     108                            img = (BufferedImage) rescale(result.getImage());
    118109                        }
     110                        if (temporary) {
     111                            disabledImgCache = null;
     112                            Main.map.mapView.preferenceChanged(null); // otherwise repaint is ignored, because layer hasn't changed
     113                            Main.map.mapView.repaint();
     114                        }
     115                        temporary = false;
    119116                    }
    120117                }

  • trunk/src/org/openstreetmap/josm/gui/oauth/FullyAutomaticAuthorizationUI.java

    r10369 r10611  
    465465
    466466        protected void handleException(final OsmOAuthAuthorizationException e) {
    467             Runnable r = new Runnable() {
    468                 @Override
    469                 public void run() {
    470                     if (e instanceof OsmLoginFailedException) {
    471                         alertLoginFailed((OsmLoginFailedException) e);
    472                     } else {
    473                         alertAuthorisationFailed(e);
    474                     }
     467            Runnable r = () -> {
     468                if (e instanceof OsmLoginFailedException) {
     469                    alertLoginFailed((OsmLoginFailedException) e);
     470                } else {
     471                    alertAuthorisationFailed(e);
    475472                }
    476473            };
    … …  
    505502                getProgressMonitor().worked(1);
    506503                if (canceled) return;
    507                 GuiHelper.runInEDT(new Runnable() {
    508                     @Override
    509                     public void run() {
    510                         prepareUIForResultDisplay();
    511                         setAccessToken(accessToken);
    512                     }
     504                GuiHelper.runInEDT(() -> {
     505                    prepareUIForResultDisplay();
     506                    setAccessToken(accessToken);
    513507                });
    514508            } catch (final OsmOAuthAuthorizationException e) {

  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveAccessTokenTask.java

    r9256 r10611  
    9090        } catch (final OsmOAuthAuthorizationException e) {
    9191            Main.error(e);
    92             GuiHelper.runInEDT(new Runnable() {
    93                 @Override
    94                 public void run() {
    95                     alertRetrievingAccessTokenFailed(e);
    96                 }
    97             });
     92            GuiHelper.runInEDT(() -> alertRetrievingAccessTokenFailed(e));
    9893            accessToken = null;
    9994        } finally {

  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveRequestTokenTask.java

    r9354 r10611  
    8484        } catch (final OsmOAuthAuthorizationException e) {
    8585            Main.error(e);
    86             GuiHelper.runInEDT(new Runnable() {
    87                 @Override
    88                 public void run() {
    89                     alertRetrievingRequestTokenFailed(e);
    90                 }
    91             });
     86            GuiHelper.runInEDT(() -> alertRetrievingRequestTokenFailed(e));
    9287            requestToken = null;
    9388        } finally {

  • trunk/src/org/openstreetmap/josm/gui/oauth/SemiAutomaticAuthorizationUI.java

    r10378 r10611  
    1313import java.awt.event.ActionEvent;
    1414import java.awt.event.ItemEvent;
    15 import java.awt.event.ItemListener;
    1615import java.util.concurrent.Executor;
    1716
    … …  
    143142            cbShowAdvancedParameters.setSelected(false);
    144143            cbShowAdvancedParameters.addItemListener(
    145                     new ItemListener() {
    146                         @Override
    147                         public void itemStateChanged(ItemEvent evt) {
    148                             getAdvancedPropertiesPanel().setVisible(evt.getStateChange() == ItemEvent.SELECTED);
    149                         }
    150                     }
     144                    evt -> getAdvancedPropertiesPanel().setVisible(evt.getStateChange() == ItemEvent.SELECTED)
    151145            );
    152146
    … …  
    400394            );
    401395            executor.execute(task);
    402             Runnable r = new Runnable() {
    403                 @Override
    404                 public void run() {
    405                     if (task.isCanceled()) return;
    406                     if (task.getRequestToken() == null) return;
    407                     requestToken = task.getRequestToken();
    408                     GuiHelper.runInEDT(new Runnable() {
    409                         @Override
    410                         public void run() {
    411                             transitionToRetrieveAccessToken();
    412                         }
    413                     });
    414                 }
     396            Runnable r = () -> {
     397                if (task.isCanceled()) return;
     398                if (task.getRequestToken() == null) return;
     399                requestToken = task.getRequestToken();
     400                GuiHelper.runInEDT(SemiAutomaticAuthorizationUI.this::transitionToRetrieveAccessToken);
    415401            };
    416402            executor.execute(r);
    … …  
    437423            );
    438424            executor.execute(task);
    439             Runnable r = new Runnable() {
    440                 @Override
    441                 public void run() {
    442                     if (task.isCanceled()) return;
    443                     if (task.getAccessToken() == null) return;
    444                     GuiHelper.runInEDT(new Runnable() {
    445                         @Override
    446                         public void run() {
    447                             setAccessToken(task.getAccessToken());
    448                             transitionToShowAccessToken();
    449                         }
    450                     });
    451                 }
     425            Runnable r = () -> {
     426                if (task.isCanceled()) return;
     427                if (task.getAccessToken() == null) return;
     428                GuiHelper.runInEDT(() -> {
     429                    setAccessToken(task.getAccessToken());
     430                    transitionToShowAccessToken();
     431                });
    452432            };
    453433            executor.execute(r);

  • trunk/src/org/openstreetmap/josm/gui/preferences/PreferenceDialog.java

    r10369 r10611  
    1212import java.awt.Insets;
    1313import java.awt.event.ActionEvent;
    14 import java.awt.event.ActionListener;
    1514import java.awt.event.KeyEvent;
    1615import java.awt.event.WindowAdapter;
    … …  
    1918import javax.swing.AbstractAction;
    2019import javax.swing.BorderFactory;
     20import javax.swing.JButton;
    2121import javax.swing.JCheckBox;
    2222import javax.swing.JComponent;
    23 import javax.swing.JButton;
    2423import javax.swing.JDialog;
    2524import javax.swing.JPanel;
    … …  
    5857        JCheckBox expert = new JCheckBox(tr("Expert mode"));
    5958        expert.setSelected(ExpertToggleAction.isExpert());
    60         expert.addActionListener(new ActionListener() {
    61             @Override
    62             public void actionPerformed(ActionEvent e) {
    63                 ExpertToggleAction.getInstance().actionPerformed(null);
    64             }
    65         });
     59        expert.addActionListener(e -> ExpertToggleAction.getInstance().actionPerformed(null));
    6660
    6761        JPanel btns = new JPanel(new FlowLayout(FlowLayout.CENTER));

  • trunk/src/org/openstreetmap/josm/gui/preferences/PreferenceTabbedPane.java

    r10600 r10611  
    322322
    323323    public void selectTabByName(String name) {
    324         selectTabBy(new TabIdentifier() {
    325             @Override
    326             public boolean identify(TabPreferenceSetting tps, Object name) {
    327                 return name != null && tps != null && tps.getIconName() != null && name.equals(tps.getIconName());
    328             }
    329         }, name);
     324        selectTabBy((tps, name1) -> name1 != null && tps != null && tps.getIconName() != null && name1.equals(tps.getIconName()), name);
    330325    }
    331326
    332327    public void selectTabByPref(Class<? extends TabPreferenceSetting> clazz) {
    333         selectTabBy(new TabIdentifier() {
    334             @Override
    335             public boolean identify(TabPreferenceSetting tps, Object clazz) {
    336                 return tps.getClass().isAssignableFrom((Class<?>) clazz);
    337             }
    338         }, clazz);
     328        selectTabBy((tps, clazz1) -> tps.getClass().isAssignableFrom((Class<?>) clazz1), clazz);
    339329    }
    340330
    … …  
    344334                final SubPreferenceSetting sub = (SubPreferenceSetting) setting;
    345335                final TabPreferenceSetting tab = sub.getTabPreferenceSetting(this);
    346                 selectTabBy(new TabIdentifier() {
    347                     @Override
    348                     public boolean identify(TabPreferenceSetting tps, Object unused) {
    349                         return tps.equals(tab);
    350                     }
    351                 }, null);
     336                selectTabBy((tps, unused) -> tps.equals(tab), null);
    352337                return tab.selectSubTab(sub);
    353338            }
    … …  
    419404    public void savePreferences() {
    420405        // create a task for downloading plugins if the user has activated, yet not downloaded, new plugins
    421         //
    422406        final PluginPreference preference = getPluginPreference();
    423407        final Set<PluginInformation> toDownload = preference.getPluginsScheduledForUpdateOrDownload();
    … …  
    430414
    431415        // this is the task which will run *after* the plugins are downloaded
    432         //
    433416        final Runnable continuation = new PluginDownloadAfterTask(preference, task, toDownload);
    434417
    … …  
    436419            // if we have to launch a plugin download task we do it asynchronously, followed
    437420            // by the remaining "save preferences" activites run on the Swing EDT.
    438             //
    439421            Main.worker.submit(task);
    440             Main.worker.submit(
    441                     new Runnable() {
    442                         @Override
    443                         public void run() {
    444                             SwingUtilities.invokeLater(continuation);
    445                         }
    446                     }
    447                     );
     422            Main.worker.submit(() -> SwingUtilities.invokeLater(continuation));
    448423        } else {
    449424            // no need for asynchronous activities. Simply run the remaining "save preference"
    450425            // activities on this thread (we are already on the Swing EDT
    451             //
    452426            continuation.run();
    453427        }

  • trunk/src/org/openstreetmap/josm/gui/preferences/SourceEditor.java

    r10482 r10611  
    1818import java.awt.event.MouseAdapter;
    1919import java.awt.event.MouseEvent;
    20 import java.beans.PropertyChangeEvent;
    21 import java.beans.PropertyChangeListener;
    2220import java.io.BufferedReader;
    2321import java.io.File;
    … …  
    2927import java.util.Collection;
    3028import java.util.Collections;
    31 import java.util.Comparator;
    3229import java.util.EventObject;
    3330import java.util.HashMap;
    … …  
    6663import javax.swing.event.CellEditorListener;
    6764import javax.swing.event.ChangeEvent;
    68 import javax.swing.event.ChangeListener;
    6965import javax.swing.event.DocumentEvent;
    7066import javax.swing.event.DocumentListener;
    … …  
    165161        }
    166162
    167         activeSourcesModel.addTableModelListener(new TableModelListener() {
    168             @Override
    169             public void tableChanged(TableModelEvent e) {
    170                 listCellRenderer.updateSources(activeSourcesModel.getSources());
    171                 lstAvailableSources.repaint();
    172             }
     163        activeSourcesModel.addTableModelListener(e -> {
     164            listCellRenderer.updateSources(activeSourcesModel.getSources());
     165            lstAvailableSources.repaint();
    173166        });
    174         tblActiveSources.addPropertyChangeListener(new PropertyChangeListener() {
    175             @Override
    176             public void propertyChange(PropertyChangeEvent evt) {
    177                 listCellRenderer.updateSources(activeSourcesModel.getSources());
    178                 lstAvailableSources.repaint();
    179             }
     167        tblActiveSources.addPropertyChangeListener(evt -> {
     168            listCellRenderer.updateSources(activeSourcesModel.getSources());
     169            lstAvailableSources.repaint();
    180170        });
    181         activeSourcesModel.addTableModelListener(new TableModelListener() {
    182             // Force swing to show horizontal scrollbars for the JTable
    183             // Yes, this is a little ugly, but should work
    184             @Override
    185             public void tableChanged(TableModelEvent e) {
    186                 TableHelper.adjustColumnWidth(tblActiveSources, canEnable ? 1 : 0, 800);
    187             }
    188         });
     171        // Force Swing to show horizontal scrollbars for the JTable
     172        // Yes, this is a little ugly, but should work
     173        activeSourcesModel.addTableModelListener(e -> TableHelper.adjustColumnWidth(tblActiveSources, canEnable ? 1 : 0, 800));
    189174        activeSourcesModel.setActiveSources(getInitialSourcesList());
    190175
    … …  
    12381223
    12391224        protected void sort() {
    1240             Collections.sort(
    1241                     data,
    1242                     new Comparator<String>() {
    1243                         @Override
    1244                         public int compare(String o1, String o2) {
    1245                             if (o1.isEmpty() && o2.isEmpty())
    1246                                 return 0;
    1247                             if (o1.isEmpty()) return 1;
    1248                             if (o2.isEmpty()) return -1;
    1249                             return o1.compareTo(o2);
    1250                         }
    1251                     }
    1252                     );
     1225            Collections.sort(data,
     1226                    (o1, o2) -> {
     1227                        if (o1.isEmpty() && o2.isEmpty())
     1228                            return 0;
     1229                        if (o1.isEmpty()) return 1;
     1230                        if (o2.isEmpty()) return -1;
     1231                        return o1.compareTo(o2);
     1232                    });
    12531233        }
    12541234
    … …  
    13801360            final String msg = tr(getStr(I18nString.FAILED_TO_LOAD_SOURCES_FROM), url, emsg);
    13811361
    1382             GuiHelper.runInEDT(new Runnable() {
    1383                 @Override
    1384                 public void run() {
    1385                     HelpAwareOptionPane.showOptionDialog(
    1386                             Main.parent,
    1387                             msg,
    1388                             tr("Error"),
    1389                             JOptionPane.ERROR_MESSAGE,
    1390                             ht(getStr(I18nString.FAILED_TO_LOAD_SOURCES_FROM_HELP_TOPIC))
    1391                             );
    1392                 }
    1393             });
     1362            GuiHelper.runInEDT(() -> HelpAwareOptionPane.showOptionDialog(
     1363                    Main.parent,
     1364                    msg,
     1365                    tr("Error"),
     1366                    JOptionPane.ERROR_MESSAGE,
     1367                    ht(getStr(I18nString.FAILED_TO_LOAD_SOURCES_FROM_HELP_TOPIC))
     1368                    ));
    13941369        }
    13951370
    … …  
    17461721     */
    17471722    public final void deferLoading(final DefaultTabPreferenceSetting tab, final Component component) {
    1748         tab.getTabPane().addChangeListener(
    1749                 new ChangeListener() {
    1750                     @Override
    1751                     public void stateChanged(ChangeEvent e) {
    1752                         if (tab.getTabPane().getSelectedComponent() == component) {
    1753                             SourceEditor.this.initiallyLoadAvailableSources();
    1754                         }
    1755                     }
    1756                 }
    1757                 );
     1723        tab.getTabPane().addChangeListener(e -> {
     1724            if (tab.getTabPane().getSelectedComponent() == component) {
     1725                SourceEditor.this.initiallyLoadAvailableSources();
     1726            }
     1727        });
    17581728    }
    17591729

  • trunk/src/org/openstreetmap/josm/gui/preferences/ToolbarPreferences.java

    r10378 r10611  
    1818import java.awt.event.InputEvent;
    1919import java.awt.event.KeyEvent;
    20 import java.beans.PropertyChangeEvent;
    21 import java.beans.PropertyChangeListener;
    2220import java.io.IOException;
    2321import java.util.ArrayList;
    … …  
    5149import javax.swing.MenuElement;
    5250import javax.swing.TransferHandler;
    53 import javax.swing.event.ListSelectionEvent;
    54 import javax.swing.event.ListSelectionListener;
    5551import javax.swing.event.PopupMenuEvent;
    5652import javax.swing.event.PopupMenuListener;
    57 import javax.swing.event.TreeSelectionEvent;
    58 import javax.swing.event.TreeSelectionListener;
    5953import javax.swing.table.AbstractTableModel;
    6054import javax.swing.tree.DefaultMutableTreeNode;
    … …  
    6963import org.openstreetmap.josm.actions.ParameterizedAction;
    7064import org.openstreetmap.josm.actions.ParameterizedActionDecorator;
    71 import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
    72 import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
    7365import org.openstreetmap.josm.gui.tagging.presets.TaggingPreset;
    7466import org.openstreetmap.josm.tools.GBC;
    … …  
    762754            };
    763755            selectedList.setCellRenderer(renderer);
    764             selectedList.addListSelectionListener(new ListSelectionListener() {
    765                 @Override
    766                 public void valueChanged(ListSelectionEvent e) {
    767                     boolean sel = selectedList.getSelectedIndex() != -1;
    768                     if (sel) {
    769                         actionsTr