Ticket #11355: 11355.patch

File 11355.patch, 18.7 KB (added by simon04, 11 years ago)

  • src/org/openstreetmap/josm/Main.java 

    diff --git a/src/org/openstreetmap/josm/Main.java b/src/org/openstreetmap/josm/Main.java
index 2a14c05..fd0a939 100644
    a b public abstract class Main {  
    529529
    530530    public static interface InitStatusListener {
    531531
    532         void updateStatus(String event);
     532        Object updateStatus(String event);
     533        void finish(Object status);
    533534    }
    534535
    535536    public static void setInitStatusListener(InitStatusListener listener) {
     537        CheckParameterUtil.ensureParameterNotNull(listener);
    536538        initListener = listener;
    537539    }
    538540
    … … public abstract class Main {  
    543545        main = this;
    544546        isOpenjdk = System.getProperty("java.vm.name").toUpperCase().indexOf("OPENJDK") != -1;
    545547
    546         if (initListener != null) {
    547             initListener.updateStatus(tr("Executing platform startup hook"));
    548         }
    549         platform.startupHook();
     548        new InitializationTask(tr("Executing platform startup hook")) {
     549            @Override
     550            public void initialize() {
     551                platform.startupHook();
     552            }
     553        }.call();
    550554
    551         if (initListener != null) {
    552             initListener.updateStatus(tr("Building main menu"));
    553         }
    554         contentPanePrivate.add(panel, BorderLayout.CENTER);
    555         panel.add(gettingStarted, BorderLayout.CENTER);
    556         menu = new MainMenu();
     555        new InitializationTask(tr("Building main menu")) {
     556
     557            @Override
     558            public void initialize() {
     559                contentPanePrivate.add(panel, BorderLayout.CENTER);
     560                panel.add(gettingStarted, BorderLayout.CENTER);
     561                menu = new MainMenu();
     562            }
     563        }.call();
    557564
    558565        undoRedo.addCommandQueueListener(redoUndoListener);
    559566
    … … public abstract class Main {  
    569576        tasks.add(new InitializationTask(tr("Initializing OSM API")) {
    570577
    571578            @Override
    572             public void initialize() throws Exception {
     579            public void initialize() {
    573580                // We try to establish an API connection early, so that any API
    574581                // capabilities are already known to the editor instance. However
    575582                // if it goes wrong that's not critical at this stage.
    … … public abstract class Main {  
    584591        tasks.add(new InitializationTask(tr("Initializing validator")) {
    585592
    586593            @Override
    587             public void initialize() throws Exception {
     594            public void initialize() {
    588595                validator = new OsmValidator();
    589596                MapView.addLayerChangeListener(validator);
    590597            }
    … … public abstract class Main {  
    593600        tasks.add(new InitializationTask(tr("Initializing presets")) {
    594601
    595602            @Override
    596             public void initialize() throws Exception {
     603            public void initialize() {
    597604                TaggingPresets.initialize();
    598605            }
    599606        });
    … … public abstract class Main {  
    601608        tasks.add(new InitializationTask(tr("Initializing map styles")) {
    602609
    603610            @Override
    604             public void initialize() throws Exception {
     611            public void initialize() {
    605612                MapPaintPreference.initialize();
    606613            }
    607614        });
    … … public abstract class Main {  
    609616        tasks.add(new InitializationTask(tr("Loading imagery preferences")) {
    610617
    611618            @Override
    612             public void initialize() throws Exception {
     619            public void initialize() {
    613620                ImageryPreference.initialize();
    614621            }
    615622        });
    … … public abstract class Main {  
    668675            }
    669676        });
    670677
    671         if (initListener != null) {
    672             initListener.updateStatus(tr("Updating user interface"));
    673         }
     678        new InitializationTask(tr("Updating user interface")) {
    674679
    675         toolbar.refreshToolbarControl();
    676 
    677         toolbar.control.updateUI();
    678         contentPanePrivate.updateUI();
     680            @Override
     681            public void initialize() {
     682                toolbar.refreshToolbarControl();
     683                toolbar.control.updateUI();
     684                contentPanePrivate.updateUI();
     685            }
     686        }.call();
    679687    }
    680688
    681689    private abstract class InitializationTask implements Callable<Void> {
    … … public abstract class Main {  
    686694            this.name = name;
    687695        }
    688696
    689         public abstract void initialize() throws Exception;
     697        public abstract void initialize();
    690698
    691699        @Override
    692         public Void call() throws Exception {
     700        public Void call() {
     701            Object status = null;
    693702            if (initListener != null) {
    694                 initListener.updateStatus(name);
     703                status = initListener.updateStatus(name);
    695704            }
    696             final long startTime = System.currentTimeMillis();
    697705            initialize();
    698             if (isDebugEnabled()) {
    699                 final long elapsedTime = System.currentTimeMillis() - startTime;
    700                 Main.debug(tr("{0} completed in {1}", name, Utils.getDurationString(elapsedTime)));
     706            if (initListener != null) {
     707                initListener.finish(status);
    701708            }
    702709            return null;
    703710        }

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

    diff --git a/src/org/openstreetmap/josm/gui/MainApplication.java b/src/org/openstreetmap/josm/gui/MainApplication.java
index 8568f7e..bb0518c 100644
    a b import org.openstreetmap.josm.data.Version;  
    5050import org.openstreetmap.josm.gui.download.DownloadDialog;
    5151import org.openstreetmap.josm.gui.preferences.server.OAuthAccessTokenHolder;
    5252import org.openstreetmap.josm.gui.preferences.server.ProxyPreference;
    53 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    5453import org.openstreetmap.josm.gui.util.GuiHelper;
    5554import org.openstreetmap.josm.io.DefaultProxySelector;
    5655import org.openstreetmap.josm.io.MessageNotifier;
    … … public class MainApplication extends Main {  
    411410        OAuthAccessTokenHolder.getInstance().init(Main.pref, CredentialsManager.getInstance());
    412411
    413412        final SplashScreen splash = new SplashScreen();
    414         final ProgressMonitor monitor = splash.getProgressMonitor();
     413        final SplashScreen.SplashProgressMonitor monitor = splash.getProgressMonitor();
    415414        monitor.beginTask(tr("Initializing"));
    416415        splash.setVisible(Main.pref.getBoolean("draw.splashscreen", true));
    417416        Main.setInitStatusListener(new InitStatusListener() {
    418417
    419418            @Override
    420             public void updateStatus(String event) {
    421                 monitor.indeterminateSubTask(event);
     419            public Object updateStatus(String event) {
     420                monitor.beginTask(event);
     421                return event;
     422            }
     423
     424            @Override
     425            public void finish(Object status) {
     426                if (status instanceof String) {
     427                    monitor.finishTask((String) status);
     428                }
    422429            }
    423430        });
    424431

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

    diff --git a/src/org/openstreetmap/josm/gui/SplashScreen.java b/src/org/openstreetmap/josm/gui/SplashScreen.java
index 1336867..c786ff2 100644
    a b package org.openstreetmap.josm.gui;  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    66import java.awt.Color;
    7 import java.awt.Dimension;
     7import java.awt.Component;
     8import java.awt.Graphics;
    89import java.awt.GridBagConstraints;
    910import java.awt.GridBagLayout;
    1011import java.awt.Image;
    1112import java.awt.Insets;
    1213import java.awt.event.MouseAdapter;
    1314import java.awt.event.MouseEvent;
    14 import java.util.Arrays;
    15 import java.util.LinkedList;
     15import java.util.Collections;
     16import java.util.LinkedHashMap;
     17import java.util.Map;
     18import java.util.Objects;
    1619
    1720import javax.swing.ImageIcon;
    1821import javax.swing.JFrame;
    … … import javax.swing.border.Border;  
    2427import javax.swing.border.EmptyBorder;
    2528import javax.swing.border.EtchedBorder;
    2629
     30import org.openstreetmap.josm.Main;
    2731import org.openstreetmap.josm.data.Version;
    2832import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    29 import org.openstreetmap.josm.gui.progress.ProgressRenderer;
    30 import org.openstreetmap.josm.gui.progress.SwingRenderingProgressMonitor;
     33import org.openstreetmap.josm.gui.progress.ProgressTaskId;
    3134import org.openstreetmap.josm.gui.util.GuiHelper;
    3235import org.openstreetmap.josm.tools.ImageProvider;
    3336import org.openstreetmap.josm.tools.Utils;
    … … import org.openstreetmap.josm.tools.WindowGeometry;  
    3942 */
    4043public class SplashScreen extends JFrame {
    4144
    42     private final SwingRenderingProgressMonitor progressMonitor;
     45    private final SplashProgressMonitor progressMonitor;
     46    public final SplashScreenProgressRenderer progressRenderer;
    4347
    4448    /**
    4549     * Constructs a new {@code SplashScreen}.
    … … public class SplashScreen extends JFrame {  
    8993        innerContentPane.add(separator, gbc);
    9094
    9195        // Add a status message
    92         SplashScreenProgressRenderer progressRenderer = new SplashScreenProgressRenderer();
     96        progressRenderer = new SplashScreenProgressRenderer();
    9397        gbc.gridy = 3;
    9498        gbc.insets = new Insets(0, 0, 10, 0);
    9599        innerContentPane.add(progressRenderer, gbc);
    96         progressMonitor = new SwingRenderingProgressMonitor(progressRenderer);
     100        progressMonitor = new SplashProgressMonitor(null);
    97101
    98102        pack();
    99103
    … … public class SplashScreen extends JFrame {  
    108112        });
    109113    }
    110114
     115    void updateProgress() {
     116        progressRenderer.setTasks("<html><style>ul {margin-top: 0; margin-bottom: 0; padding: 0;} li {margin: 0; padding: 0;}</style>"
     117                + progressMonitor.toString());
     118    }
     119
     120    private static class MeasurableTask {
     121        private final String name;
     122        private final long start;
     123        private String duration = "";
     124
     125        public MeasurableTask(String name) {
     126            this.name = name;
     127            this.start = System.currentTimeMillis();
     128        }
     129
     130        public void finish() {
     131            duration = tr(" ({0})", Utils.getDurationString(System.currentTimeMillis() - start));
     132        }
     133
     134        @Override
     135        public String toString() {
     136            return name + "<i style='color: #666666;'>" + duration + "</i>";
     137        }
     138
     139        @Override
     140        public boolean equals(Object o) {
     141            if (this == o) return true;
     142            if (o == null || getClass() != o.getClass()) return false;
     143            MeasurableTask that = (MeasurableTask) o;
     144            return Objects.equals(name, that.name);
     145        }
     146
     147        @Override
     148        public int hashCode() {
     149            return Objects.hashCode(name);
     150        }
     151    }
     152
     153    class SplashProgressMonitor implements ProgressMonitor {
     154
     155        private final String name;
     156        private final Map<Object, Object> tasks = Collections.synchronizedMap(new LinkedHashMap<Object, Object>() {
     157            @Override
     158            public Object put(Object key, Object value) {
     159                final Object r = super.put(key, value);
     160                updateProgress();
     161                return r;
     162            }
     163        });
     164        private SplashProgressMonitor latestSubtask;
     165
     166        public SplashProgressMonitor(String name) {
     167            this.name = name;
     168        }
     169
     170        @Override
     171        public String toString() {
     172            return Utils.firstNonNull(name, "") + (tasks.isEmpty() ? "" : Utils.joinAsHtmlUnorderedList(tasks.values()));
     173        }
     174
     175        @Override
     176        public void beginTask(String title) {
     177            if (title != null) {
     178                final MeasurableTask task = new MeasurableTask(title);
     179                tasks.put(task, task);
     180            }
     181        }
     182
     183        @Override
     184        public void beginTask(String title, int ticks) {
     185            this.beginTask(title);
     186        }
     187
     188        @Override
     189        public void setCustomText(String text) {
     190            this.beginTask(text);
     191        }
     192
     193        @Override
     194        public void setExtraText(String text) {
     195            this.beginTask(text);
     196        }
     197
     198        @Override
     199        public void indeterminateSubTask(String title) {
     200            this.subTask(title);
     201        }
     202
     203        @Override
     204        public void subTask(String title) {
     205            latestSubtask = new SplashProgressMonitor(title);
     206            tasks.put(latestSubtask, latestSubtask);
     207        }
     208
     209        @Override
     210        public ProgressMonitor createSubTaskMonitor(int ticks, boolean internal) {
     211            return latestSubtask;
     212        }
     213
     214        @Override
     215        @Deprecated
     216        public void finishTask() {
     217        }
     218
     219        public void finishTask(String title) {
     220            final Object task = tasks.get(new MeasurableTask(title));
     221            if (task instanceof MeasurableTask) {
     222                ((MeasurableTask) task).finish();
     223                Main.debug(tr("{0} completed in {1}", title, ((MeasurableTask) task).duration));
     224                updateProgress();
     225            }
     226        }
     227
     228        @Override
     229        public void invalidate() {
     230        }
     231
     232        @Override
     233        public void setTicksCount(int ticks) {
     234        }
     235
     236        @Override
     237        public int getTicksCount() {
     238            return 0;
     239        }
     240
     241        @Override
     242        public void setTicks(int ticks) {
     243        }
     244
     245        @Override
     246        public int getTicks() {
     247            return 0;
     248        }
     249
     250        @Override
     251        public void worked(int ticks) {
     252        }
     253
     254        @Override
     255        public boolean isCanceled() {
     256            return false;
     257        }
     258
     259        @Override
     260        public void cancel() {
     261        }
     262
     263        @Override
     264        public void addCancelListener(CancelListener listener) {
     265        }
     266
     267        @Override
     268        public void removeCancelListener(CancelListener listener) {
     269        }
     270
     271        @Override
     272        public void appendLogMessage(String message) {
     273        }
     274
     275        @Override
     276        public void setProgressTaskId(ProgressTaskId taskId) {
     277        }
     278
     279        @Override
     280        public ProgressTaskId getProgressTaskId() {
     281            return null;
     282        }
     283
     284        @Override
     285        public Component getWindowParent() {
     286            return Main.parent;
     287        }
     288    }
     289
    111290    /**
    112291     * Returns the progress monitor.
    113292     * @return The progress monitor
    114293     */
    115     public ProgressMonitor getProgressMonitor() {
     294    public SplashProgressMonitor getProgressMonitor() {
    116295        return progressMonitor;
    117296    }
    118297
    119     private static class SplashScreenProgressRenderer extends JPanel implements ProgressRenderer {
     298    private static class SplashScreenProgressRenderer extends JPanel {
    120299        private JLabel lblTaskTitle;
    121         private JLabel lblCustomText;
    122300        private JProgressBar progressBar;
    123301
    124302        protected void build() {
    … … public class SplashScreen extends JFrame {  
    132310            gc.insets = new Insets(5,0,0,0);
    133311            add(lblTaskTitle = new JLabel(" "), gc);
    134312
    135             gc.gridx = 0;
    136313            gc.gridy = 1;
    137             gc.fill = GridBagConstraints.HORIZONTAL;
    138             gc.weightx = 1.0;
    139             gc.weighty = 0.0;
    140             gc.insets = new Insets(5,0,0,0);
    141             add(lblCustomText = new JLabel(" ") {
    142                 @Override
    143                 public Dimension getPreferredSize() {
    144                     Dimension d = super.getPreferredSize();
    145                     if(d.width < 600) d.width = 600;
    146                     d.height *= MAX_NUMBER_OF_MESSAGES;
    147                     return d;
    148                 }
    149             }, gc);
    150 
    151             gc.gridx = 0;
    152             gc.gridy = 2;
    153             gc.fill = GridBagConstraints.HORIZONTAL;
    154             gc.weightx = 1.0;
    155             gc.weighty = 0.0;
    156             gc.insets = new Insets(5,0,0,0);
     314            gc.insets = new Insets(15,0,0,0);
    157315            add(progressBar = new JProgressBar(JProgressBar.HORIZONTAL), gc);
     316            progressBar.setIndeterminate(true);
    158317        }
    159318
    160319        public SplashScreenProgressRenderer() {
    … … public class SplashScreen extends JFrame {  
    162321        }
    163322
    164323        @Override
    165         public void setCustomText(String message) {
    166             if(message.isEmpty())
    167                 message = " "; // prevent killing of additional line
    168             lblCustomText.setText(message);
    169             repaint();
    170         }
    171 
    172         @Override
    173         public void setIndeterminate(boolean indeterminate) {
    174             progressBar.setIndeterminate(indeterminate);
    175             repaint();
    176         }
    177 
    178         @Override
    179         public void setMaximum(int maximum) {
    180             progressBar.setMaximum(maximum);
    181             repaint();
    182         }
    183 
    184         private static final int MAX_NUMBER_OF_MESSAGES = 3;
    185         private LinkedList<String> messages = new LinkedList<>(Arrays.asList("", "", "")); //update when changing MAX_NUMBER_OF_MESSAGES
    186         private long time = System.currentTimeMillis();
    187 
    188         /**
    189          * Stores and displays the {@code MAX_NUMBER_OF_MESSAGES} most recent
    190          * task titles together with their execution time.
    191          */
    192         @Override
    193         public void setTaskTitle(String taskTitle) {
    194 
    195             while (messages.size() >= MAX_NUMBER_OF_MESSAGES) {
    196                 messages.removeFirst();
    197             }
    198             long now = System.currentTimeMillis();
    199             String prevMessageTitle = messages.getLast();
    200             // now should always be >= time but if can be inferior sometimes, see #10287
    201             if (!prevMessageTitle.isEmpty() && now >= time) {
    202                 messages.removeLast();
    203                 messages.add(tr("{0} ({1})", prevMessageTitle, Utils.getDurationString(now - time)));
     324        public void paint(Graphics g) {
     325            try {
     326                super.paint(g);
     327            } catch (NullPointerException ignore) {
     328                // NullPointerException at javax.swing.text.html.StyleSheet$ListPainter.paint
    204329            }
    205             time = now;
    206             if (!taskTitle.isEmpty()) {
    207                 messages.add(taskTitle);
    208             }
    209             StringBuilder html = new StringBuilder();
    210             int i = 0;
    211             for (String m : messages) {
    212                 html.append("<p class=\"entry").append(++i).append("\">").append(m).append("</p>");
    213             }
    214 
    215             lblTaskTitle.setText("<html><style>"
    216                     + ".entry1{color:#CCCCCC;}"
    217                     + ".entry2{color:#999999;}"
    218                     + ".entry3{color:#000000;}</style>" + html + "</html>");  //update when changing MAX_NUMBER_OF_MESSAGES
    219             repaint();
    220330        }
    221331
    222         @Override
    223         public void setValue(int value) {
    224             progressBar.setValue(value);
     332        public void setTasks(String tasks) {
     333            lblTaskTitle.setText(tasks);
    225334            repaint();
    226335        }
    227336    }