Changeset 4718 in josm


Ignore:
Timestamp:
2011-12-27T12:56:27+01:00 (8 years ago)
Author:
jttt
Message:

Add posibility to run please wait runnable tasks in background

Location:
trunk/src/org/openstreetmap/josm
Files:
3 added
13 edited

Legend:

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

    r4681 r4718  
    2222import java.util.Collection;
    2323import java.util.Iterator;
    24 import java.util.LinkedList;
    2524import java.util.List;
    2625import java.util.Map;
    2726import java.util.StringTokenizer;
    2827import java.util.concurrent.ExecutorService;
    29 import java.util.concurrent.Executors;
    3028import java.util.concurrent.Future;
    3129import java.util.regex.Matcher;
     
    4139import javax.swing.JTextArea;
    4240import javax.swing.KeyStroke;
     41import javax.swing.RepaintManager;
    4342import javax.swing.UIManager;
    4443
     44import org.jdesktop.swinghelper.debug.CheckThreadViolationRepaintManager;
    4545import org.openstreetmap.gui.jmapviewer.FeatureAdapter;
    4646import org.openstreetmap.josm.actions.JosmAction;
     
    7676import org.openstreetmap.josm.gui.preferences.TaggingPresetPreference;
    7777import org.openstreetmap.josm.gui.preferences.ToolbarPreferences;
     78import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
     79import org.openstreetmap.josm.gui.progress.ProgressMonitorExecutor;
    7880import org.openstreetmap.josm.io.OsmApi;
    7981import org.openstreetmap.josm.plugins.PluginHandler;
     
    116118     * and sequential.
    117119     */
    118     public final static ExecutorService worker = Executors.newSingleThreadExecutor();
     120    public final static ExecutorService worker = new ProgressMonitorExecutor();
    119121    /**
    120122     * Global application preferences
     
    143145
    144146    public UndoRedoHandler undoRedo = new UndoRedoHandler();
     147
     148    public static PleaseWaitProgressMonitor currentProgressMonitor;
    145149
    146150    /**
     
    208212
    209213        PluginHandler.notifyMapFrameChanged(old, map);
     214        if (map == null && currentProgressMonitor != null) {
     215            currentProgressMonitor.showForegroundDialog();
     216        }
    210217    }
    211218
     
    238245        isOpenjdk = System.getProperty("java.vm.name").toUpperCase().indexOf("OPENJDK") != -1;
    239246
    240         if (initListener != null)
     247        if (initListener != null) {
    241248            initListener.updateStatus(tr("Executing platform startup hook"));
     249        }
    242250        platform.startupHook();
    243251
     
    245253        // capabilities are already known to the editor instance. However
    246254        // if it goes wrong that's not critical at this stage.
    247         if (initListener != null)
     255        if (initListener != null) {
    248256            initListener.updateStatus(tr("Initializing OSM API"));
     257        }
    249258        try {
    250259            OsmApi.getOsmApi().initialize(null, true);
     
    253262        }
    254263
    255         if (initListener != null)
     264        if (initListener != null) {
    256265            initListener.updateStatus(tr("Building main menu"));
     266        }
    257267        contentPanePrivate.add(panel, BorderLayout.CENTER);
    258268        panel.add(gettingStarted, BorderLayout.CENTER);
     
    267277                KeyEvent.VK_F1, Shortcut.GROUP_DIRECT));
    268278
    269         if (initListener != null)
     279        if (initListener != null) {
    270280            initListener.updateStatus(tr("Initializing presets"));
     281        }
    271282        TaggingPresetPreference.initialize();
    272283
    273         if (initListener != null)
     284        if (initListener != null) {
    274285            initListener.updateStatus(tr("Initializing map styles"));
     286        }
    275287        MapPaintPreference.initialize();
    276288
    277         if (initListener != null)
     289        if (initListener != null) {
    278290            initListener.updateStatus(tr("Loading imagery preferences"));
     291        }
    279292        ImageryPreference.initialize();
    280293
    281         if (initListener != null)
     294        if (initListener != null) {
    282295            initListener.updateStatus(tr("Initializing validator"));
     296        }
    283297        validator = new OsmValidator();
    284298        MapView.addLayerChangeListener(validator);
     
    293307        FeatureAdapter.registerTranslationAdapter(I18n.getTranslationAdapter());
    294308
    295         if (initListener != null)
     309        if (initListener != null) {
    296310            initListener.updateStatus(tr("Updating user interface"));
     311        }
    297312
    298313        toolbar.refreshToolbarControl();
     
    527542                                tr("Warning"),
    528543                                JOptionPane.WARNING_MESSAGE
    529                         );
     544                                );
    530545                    }
    531546                    if (f!=null) {
     
    560575                            tr("Warning"),
    561576                            JOptionPane.WARNING_MESSAGE
    562                     );
     577                            );
    563578                }
    564579            }
     
    647662                    tr("Warning"),
    648663                    JOptionPane.WARNING_MESSAGE
    649             );
     664                    );
    650665        } else {
    651666            downloadFromParamBounds(rawGps, b);
     
    664679                    new LatLon(Double.parseDouble(st.nextToken()),Double.parseDouble(st.nextToken())),
    665680                    new LatLon(Double.parseDouble(st.nextToken()),Double.parseDouble(st.nextToken()))
    666             );
     681                    );
    667682            downloadFromParamBounds(rawGps, b);
    668683        }
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadGpsTask.java

    r4521 r4718  
    1515import org.openstreetmap.josm.gui.layer.Layer;
    1616import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     17import org.openstreetmap.josm.gui.progress.ProgressTaskId;
     18import org.openstreetmap.josm.gui.progress.ProgressTaskIds;
    1719import org.openstreetmap.josm.io.BoundingBoxDownloader;
    1820import org.openstreetmap.josm.io.OsmServerLocationReader;
     
    2426
    2527    private DownloadTask downloadTask;
    26    
     28
    2729    private static final String PATTERN_TRACE_ID = "http://.*openstreetmap.org/trace/\\p{Digit}+/data";
    28    
     30
    2931    private static final String PATTERN_TRACKPOINTS_BBOX = "http://.*/api/0.6/trackpoints\\?bbox=.*,.*,.*,.*";
    3032
     
    4446            // message if necessary. If no one calls getErrorMessage() it just behaves like execute.
    4547            return Main.worker.submit(downloadTask);
    46            
     48
    4749        } else if (url != null && url.matches(PATTERN_TRACKPOINTS_BBOX)) {
    4850            String[] table = url.split("\\?|=|&");
    4951            for (int i = 0; i<table.length; i++) {
    50                 if (table[i].equals("bbox") && i<table.length-1 ) {
     52                if (table[i].equals("bbox") && i<table.length-1 )
    5153                    return download(newLayer, new Bounds(table[i+1], ",", ParseMethod.LEFT_BOTTOM_RIGHT_TOP), progressMonitor);
    52                 }
    5354            }
    5455        }
     
    124125                if (l instanceof GpxLayer &&  (merge || ((GpxLayer)l).data.fromServer))
    125126                    return l;
    126             return null;
     127                    return null;
    127128        }
    128129
     
    133134            }
    134135        }
     136
     137        @Override
     138        public ProgressTaskId canRunInBackground() {
     139            return ProgressTaskIds.DOWNLOAD_GPS;
     140        }
    135141    }
    136142}
  • trunk/src/org/openstreetmap/josm/gui/MapStatus.java

    r4604 r4718  
    3232import javax.swing.JLabel;
    3333import javax.swing.JPanel;
     34import javax.swing.JProgressBar;
    3435import javax.swing.JScrollPane;
    3536import javax.swing.JTextField;
    3637import javax.swing.Popup;
    3738import javax.swing.PopupFactory;
     39import javax.swing.UIManager;
    3840
    3941import org.openstreetmap.josm.Main;
     
    4446import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    4547import org.openstreetmap.josm.gui.help.Helpful;
     48import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
     49import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor.ProgressMonitorDialog;
    4650import org.openstreetmap.josm.tools.GBC;
    4751import org.openstreetmap.josm.tools.ImageProvider;
     
    9599    }
    96100
     101    public class BackgroundProgressMonitor implements ProgressMonitorDialog {
     102
     103        private String title;
     104        private String customText;
     105
     106        private void updateText() {
     107            if (customText != null && !customText.isEmpty()) {
     108                progressBar.setToolTipText(tr("{0} ({1})", title, customText));
     109            } else {
     110                progressBar.setToolTipText(title);
     111            }
     112        }
     113
     114        public void setVisible(boolean visible) {
     115            progressBar.setVisible(visible);
     116        }
     117
     118        public void updateProgress(int progress) {
     119            progressBar.setValue(progress);
     120            MapStatus.this.doLayout();
     121        }
     122
     123        public void setCustomText(String text) {
     124            this.customText = text;
     125            updateText();
     126        }
     127
     128        public void setTitle(String text) {
     129            this.title = text;
     130            updateText();
     131        }
     132
     133        public void setIndeterminate(boolean newValue) {
     134            UIManager.put("ProgressBar.cycleTime", UIManager.getInt("ProgressBar.repaintInterval") * 100);
     135            progressBar.setIndeterminate(newValue);
     136        }
     137
     138        @Override
     139        public void appendLogMessage(String message) {
     140            if (message != null && !message.isEmpty()) {
     141                System.out.println("appendLogMessage not implemented for background tasks. Message was: " + message);
     142            }
     143        }
     144
     145    }
     146
    97147    final ImageLabel lonText = new ImageLabel("lon", tr("The geographic longitude at the mouse pointer."), 11);
    98148    final ImageLabel nameText = new ImageLabel("name", tr("The name of the object at the mouse pointer."), 20);
     
    102152    final ImageLabel headingText = new ImageLabel("heading", tr("The (compass) heading of the line segment being drawn."), 6);
    103153    final ImageLabel distText = new ImageLabel("dist", tr("The length of the new way segment being drawn."), 10);
     154    final JProgressBar progressBar = new JProgressBar();
     155    public final BackgroundProgressMonitor progressMonitor = new BackgroundProgressMonitor();
    104156
    105157    /**
     
    658710        helpText.setEditable(false);
    659711        add(nameText, GBC.std().insets(3,0,0,0));
    660         add(helpText, GBC.eol().insets(3,0,0,0).fill(GBC.HORIZONTAL));
     712        add(helpText, GBC.std().insets(3,0,0,0).fill(GBC.HORIZONTAL));
     713
     714        progressBar.setMaximum(PleaseWaitProgressMonitor.PROGRESS_BAR_MAX);
     715        {
     716            GBC gbc = GBC.eol();
     717            gbc.ipadx = 100;
     718            add(progressBar,gbc);
     719        }
     720        progressBar.addMouseListener(new MouseAdapter() {
     721            @Override
     722            public void mouseClicked(MouseEvent e) {
     723                PleaseWaitProgressMonitor monitor = Main.currentProgressMonitor;
     724                if (monitor != null) {
     725                    monitor.showForegroundDialog();
     726                }
     727            }
     728        });
    661729
    662730        // The background thread
  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitDialog.java

    r3501 r4718  
    2424
    2525import org.openstreetmap.josm.Main;
     26import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor.ProgressMonitorDialog;
    2627import org.openstreetmap.josm.tools.GBC;
    2728import org.openstreetmap.josm.tools.ImageProvider;
    2829
    29 public class PleaseWaitDialog extends JDialog {
     30public class PleaseWaitDialog extends JDialog implements ProgressMonitorDialog {
    3031
    3132    private final JProgressBar progressBar = new JProgressBar();
     
    3435    private final JLabel customText = new JLabel("");
    3536    public final BoundedRangeModel progress = progressBar.getModel();
    36     private  JButton btnCancel;
     37    private JButton btnCancel;
     38    private JButton btnInBackground;
    3739    /** the text area and the scroll pane for the log */
    3840    private JTextArea taLog = new JTextArea(5,50);
     
    4648        pane.add(customText, GBC.eol().fill(GBC.HORIZONTAL));
    4749        pane.add(progressBar, GBC.eop().fill(GBC.HORIZONTAL));
     50        JPanel buttons = new JPanel();
     51        buttons.setLayout(new GridBagLayout());
    4852        btnCancel = new JButton(tr("Cancel"));
    4953        btnCancel.setIcon(ImageProvider.get("cancel"));
    5054        btnCancel.setToolTipText(tr("Click to cancel the current operation"));
    51         pane.add(btnCancel, GBC.eol().anchor(GBC.CENTER));
     55        buttons.add(btnCancel);
     56        btnInBackground = new JButton(tr("In background"));
     57        btnInBackground.setToolTipText(tr("Click to run job in background"));
     58        buttons.add(btnInBackground, GBC.std().fill(GBC.VERTICAL).insets(5, 0, 0, 0));
     59        pane.add(buttons, GBC.eol().anchor(GBC.CENTER));
    5260        GridBagConstraints gc = GBC.eol().fill(GBC.BOTH);
    5361        gc.weighty = 1.0;
     
    132140    }
    133141
     142    public void setInBackgroundPossible(boolean value) {
     143        btnInBackground.setVisible(value);
     144    }
     145
    134146    /**
    135147     * Installs a callback for the cancel button. If callback is null, all action listeners
     
    148160        }
    149161    }
     162
     163    /**
     164     * Installs a callback for the "In background" button. If callback is null, all action listeners
     165     * are removed from the cancel button.
     166     *
     167     * @param callback the cancel callback
     168     */   
     169    public void setInBackgroundCallback(ActionListener callback) {
     170        if (callback == null) {
     171            ActionListener[] listeners = btnInBackground.getActionListeners();
     172            for (ActionListener l: listeners) {
     173                btnInBackground.removeActionListener(l);
     174            }
     175        } else {
     176            btnInBackground.addActionListener(callback);
     177        }
     178    }
     179
     180    @Override
     181    public void updateProgress(int progress) {
     182        this.progress.setValue(progress);
     183    }
     184
    150185}
  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

    r4310 r4718  
    1111import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1212import org.openstreetmap.josm.gui.progress.ProgressMonitor.CancelListener;
     13import org.openstreetmap.josm.gui.progress.ProgressTaskId;
    1314import org.openstreetmap.josm.io.OsmTransferException;
    1415import org.openstreetmap.josm.tools.BugReportExceptionHandler;
     
    3536        this(title, false);
    3637    }
    37 
    3838    /**
    3939     * Create the runnable object with a given message for the user.
     
    7373    private void doRealRun() {
    7474        try {
     75            ProgressTaskId oldTaskId = null;
    7576            try {
    7677                progressMonitor.addCancelListener(this);
    7778                progressMonitor.beginTask(title);
     79                oldTaskId = progressMonitor.getProgressTaskId();
     80                progressMonitor.setProgressTaskId(canRunInBackground());
    7881                try {
    7982                    realRun();
     
    9295                progressMonitor.finishTask();
    9396                progressMonitor.removeCancelListener(this);
     97                progressMonitor.setProgressTaskId(oldTaskId);
    9498                if (progressMonitor instanceof PleaseWaitProgressMonitor) {
    9599                    ((PleaseWaitProgressMonitor)progressMonitor).close();
    96100                }
     101                afterFinish();
    97102            }
    98103        } catch (final Exception e) {
     
    110115            }
    111116        }
     117    }
     118
     119    /**
     120     * Can be overriden if something needs to run after progress monitor is closed.
     121     */
     122    protected void afterFinish() {
     123
    112124    }
    113125
     
    152164        return progressMonitor;
    153165    }
     166
     167    /**
     168     * Task can run in background if returned value <> null. Note that it's tasks responsibility
     169     * to ensure proper synchronization, PleaseWaitRunnable doesn't with it.
     170     * @return If returned value is <> null then task can run in background. TaskId could be used in future for "Always run in background" checkbox
     171     */
     172    public ProgressTaskId canRunInBackground() {
     173        return null;
     174    }
    154175}
  • trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

    r4701 r4718  
    10211021                    getClass().getName() + ".geometry",
    10221022                    WindowGeometry.centerInWindow(Main.parent, new Dimension(1000, 500))
    1023             );
     1023                    );
    10241024            ed.showDialog();
    10251025            int v = ed.getValue();
     
    11771177                @Override
    11781178                protected void finish() {
     1179                }
     1180
     1181                @Override
     1182                protected void afterFinish() {
    11791183                    if(cancel)
    11801184                        return;
     
    12741278
    12751279            if (toDownload.size() > 1) {
    1276                 // hide progress dialog before displaying another pop up. Really closing the
    1277                 // dialog will be handled by PleaseWaitRunnable.
    1278                 if (progressMonitor instanceof PleaseWaitProgressMonitor) {
    1279                     ((PleaseWaitProgressMonitor) progressMonitor).getDialog().setVisible(false);
    1280                 }
    1281 
    12821280                int ret = JOptionPane.showConfirmDialog(
    12831281                        Main.parent,
  • trunk/src/org/openstreetmap/josm/gui/progress/AbstractProgressMonitor.java

    r4310 r4718  
    66import java.util.LinkedList;
    77import java.util.Queue;
     8
     9import javax.swing.SwingUtilities;
    810
    911public abstract class AbstractProgressMonitor implements ProgressMonitor {
     
    6163    }
    6264
     65    protected void doInEDT(Runnable runnable) {
     66        if (SwingUtilities.isEventDispatchThread()) {
     67            runnable.run();
     68        } else {
     69            SwingUtilities.invokeLater(runnable);
     70        }
     71    }
     72
    6373    /*=======
    6474     * Tasks
     
    6979    }
    7080
    71     public synchronized void beginTask(final String title, int ticks) {
     81    public synchronized void beginTask(String title, int ticks) {
    7282        this.taskTitle = title;
    7383        checkState(State.INIT);
  • trunk/src/org/openstreetmap/josm/gui/progress/ChildProgress.java

    r4642 r4718  
    5555        parent.childFinished(this);
    5656    }
     57
     58    @Override
     59    public void setProgressTaskId(ProgressTaskId taskId) {
     60        parent.setProgressTaskId(taskId);
     61    }
     62
     63    @Override
     64    public ProgressTaskId getProgressTaskId() {
     65        return parent.getProgressTaskId();
     66    }
    5767}
  • trunk/src/org/openstreetmap/josm/gui/progress/NullProgressMonitor.java

    r4310 r4718  
    8080        return 0;
    8181    }
     82
     83    @Override
     84    public void setProgressTaskId(ProgressTaskId taskId) {
     85    }
     86
     87    @Override
     88    public ProgressTaskId getProgressTaskId() {
     89        return null;
     90    }
    8291}
  • trunk/src/org/openstreetmap/josm/gui/progress/PleaseWaitProgressMonitor.java

    r4684 r4718  
    44import java.awt.Component;
    55import java.awt.Dialog;
    6 import java.awt.EventQueue;
    76import java.awt.Frame;
    87import java.awt.Window;
     
    1615
    1716import org.openstreetmap.josm.Main;
     17import org.openstreetmap.josm.gui.MapFrame;
     18import org.openstreetmap.josm.gui.MapStatus.BackgroundProgressMonitor;
    1819import org.openstreetmap.josm.gui.PleaseWaitDialog;
    1920
    2021public class PleaseWaitProgressMonitor extends AbstractProgressMonitor {
    2122
    22     private static final int PROGRESS_BAR_MAX = 100;
     23        /**
     24         * Implemented by both foreground dialog and background progress dialog (in status bar)
     25         */
     26    public interface ProgressMonitorDialog {
     27        void setVisible(boolean visible);
     28        void updateProgress(int progress);
     29        void setCustomText(String text);
     30        void setTitle(String text);
     31        void setIndeterminate(boolean newValue);
     32        void appendLogMessage(String message);
     33    }
     34
     35    public static final int PROGRESS_BAR_MAX = 100;
    2336    private final Window dialogParent;
    2437    private int currentProgressValue = 0;
    2538
     39    private boolean isInBackground;
    2640    private PleaseWaitDialog dialog;
    2741    private String windowTitle;
    28    
     42    protected ProgressTaskId taskId;
     43
    2944    private boolean cancelable;
     45
     46    private ProgressMonitorDialog getDialog() {
     47
     48        BackgroundProgressMonitor backgroundMonitor = null;
     49        MapFrame map = Main.map;
     50        if (map != null) {
     51            backgroundMonitor = map.statusLine.progressMonitor;
     52        }
     53
     54        if (backgroundMonitor != null) {
     55            backgroundMonitor.setVisible(isInBackground);
     56        }
     57        if (dialog != null) {
     58            dialog.setVisible(!isInBackground || backgroundMonitor == null);
     59        }
     60
     61        if (isInBackground && backgroundMonitor != null) {
     62            backgroundMonitor.setVisible(true);
     63            if (dialog != null) {
     64                dialog.setVisible(false);
     65            }
     66            return backgroundMonitor;
     67        } else if (backgroundMonitor != null) {
     68            backgroundMonitor.setVisible(false);
     69            if (dialog != null) {
     70                dialog.setVisible(true);
     71            }
     72            return dialog;
     73        } else if (dialog != null) {
     74            dialog.setVisible(true);
     75            return dialog;
     76        } else
     77            return null;
     78    }
    3079
    3180    public PleaseWaitProgressMonitor() {
     
    55104    };
    56105
     106    private ActionListener inBackgroundListener = new ActionListener() {
     107        @Override
     108        public void actionPerformed(ActionEvent e) {
     109            isInBackground = true;
     110            ProgressMonitorDialog dialog = getDialog();
     111            if (dialog != null) {
     112                dialog.setVisible(true);
     113            }
     114        }
     115    };
     116
    57117    private WindowListener windowListener = new WindowAdapter(){
    58118        @Override public void windowClosing(WindowEvent e) {
     
    69129    }
    70130
    71     private void doInEDT(Runnable runnable) {
    72         EventQueue.invokeLater(runnable);
    73     }
    74 
    75131    @Override
    76132    public void doBeginTask() {
    77133        doInEDT(new Runnable() {
    78134            public void run() {
     135                Main.currentProgressMonitor = PleaseWaitProgressMonitor.this;
    79136                if (dialogParent instanceof Frame && dialog == null) {
    80137                    dialog = new PleaseWaitDialog(dialogParent);
     
    89146                dialog.setCancelEnabled(cancelable);
    90147                dialog.setCancelCallback(cancelListener);
     148                dialog.setInBackgroundCallback(inBackgroundListener);
    91149                dialog.setCustomText("");
    92150                dialog.addWindowListener(windowListener);
     
    109167            doInEDT(new Runnable() {
    110168                public void run() {
    111                     dialog.progress.setValue(currentProgressValue);
     169                    ProgressMonitorDialog dialog = getDialog();
     170                    if (dialog != null) {
     171                        dialog.updateProgress(currentProgressValue);
     172                    }
    112173                }
    113174            });
     
    120181        doInEDT(new Runnable() {
    121182            public void run() {
    122                 dialog.setCustomText(title);
     183                ProgressMonitorDialog dialog = getDialog();
     184                if (dialog != null) {
     185                    dialog.setCustomText(title);
     186                }
    123187            }
    124188        });
     
    130194        doInEDT(new Runnable() {
    131195            public void run() {
    132                 dialog.currentAction.setText(title);
     196                ProgressMonitorDialog dialog = getDialog();
     197                if (dialog != null) {
     198                    dialog.setTitle(title);
     199                }
    133200            }
    134201        });
     
    139206        doInEDT(new Runnable() {
    140207            public void run() {
    141                 if (value && dialog.progress.getValue() == 0) {
    142                     // Enable only if progress is at the beginning. Doing intermediate progress in the middle
    143                     // will hide already reached progress
    144                     dialog.setIndeterminate(true);
    145                 } else {
    146                     dialog.setIndeterminate(false);
     208                // Enable only if progress is at the beginning. Doing intermediate progress in the middle
     209                // will hide already reached progress
     210                ProgressMonitorDialog dialog = getDialog();
     211                if (dialog != null) {
     212                    dialog.setIndeterminate(value && PleaseWaitProgressMonitor.this.dialog.progress.getValue() == 0);
    147213                }
    148214            }
     
    154220        doInEDT(new Runnable() {
    155221            public void run() {
    156                 dialog.appendLogMessage(message);
     222                ProgressMonitorDialog dialog = getDialog();
     223                if (dialog != null) {
     224                    dialog.appendLogMessage(message);
     225                }
    157226            }
    158227        });
     
    160229
    161230    public void close() {
    162         dialog.setVisible(false);
    163         dialog.setCancelCallback(null);
    164         dialog.removeWindowListener(windowListener);
    165         dialog.dispose();
    166         dialog = null;
    167     }
    168    
    169     public Component getDialog() {
    170         return dialog;
    171     }
     231        doInEDT(new Runnable() {
     232            @Override
     233            public void run() {
     234                dialog.setVisible(false);
     235                dialog.setCancelCallback(null);
     236                dialog.setInBackgroundCallback(null);
     237                dialog.removeWindowListener(windowListener);
     238                dialog.dispose();
     239                dialog = null;
     240                MapFrame map = Main.map;
     241                if (map != null) {
     242                    map.statusLine.progressMonitor.setVisible(false);
     243                }
     244                Main.currentProgressMonitor = null;
     245            }
     246        });
     247    }
     248
     249    public void showForegroundDialog() {
     250        isInBackground = false;
     251        doInEDT(new Runnable() {
     252            @Override
     253            public void run() {
     254                dialog.setInBackgroundPossible(PleaseWaitProgressMonitor.this.taskId != null && Main.isDisplayingMapView());
     255                getDialog();
     256            }
     257        });
     258
     259    }
     260
     261    @Override
     262    public void setProgressTaskId(ProgressTaskId taskId) {
     263        this.taskId = taskId;
     264        doInEDT(new Runnable() {
     265            @Override
     266            public void run() {
     267                dialog.setInBackgroundPossible(PleaseWaitProgressMonitor.this.taskId != null && Main.isDisplayingMapView());
     268            }
     269        });
     270    }
     271
     272    @Override
     273    public ProgressTaskId getProgressTaskId() {
     274        return taskId;
     275    }
     276
    172277}
  • trunk/src/org/openstreetmap/josm/gui/progress/ProgressMonitor.java

    r4310 r4718  
    5050     */
    5151    void beginTask(String title, int ticks);
     52
    5253    /**
    5354     * Finish this progress monitor, close the dialog or inform the parent progress monitor
     
    5556     * then further calls are ignored)
    5657     */
     58
    5759    void finishTask();
    5860    /**
     
    126128     */
    127129    void appendLogMessage(String message);
     130
     131    /**
     132     * Should be used only by PleaseWaitRunnable. If taskId <> null then "In background" button will be shown
     133     * @param taskId
     134     */
     135    void setProgressTaskId(ProgressTaskId taskId);
     136
     137    /**
     138     * Should be used only by PleaseWaitRunnable
     139     * @param taskId
     140     */
     141    ProgressTaskId getProgressTaskId();
    128142}
  • trunk/src/org/openstreetmap/josm/gui/progress/SwingRenderingProgressMonitor.java

    r3083 r4718  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.gui.progress;
    3 
    4 import javax.swing.SwingUtilities;
    53
    64import org.openstreetmap.josm.tools.CheckParameterUtil;
     
    2725        CheckParameterUtil.ensureParameterNotNull(delegate, "delegate");
    2826        this.delegate = delegate;
    29     }
    30 
    31     private void doInEDT(Runnable runnable) {
    32         if (SwingUtilities.isEventDispatchThread()) {
    33             runnable.run();
    34         } else {
    35             SwingUtilities.invokeLater(runnable);
    36         }
    3727    }
    3828
     
    9383        });
    9484    }
     85
     86    @Override
     87    public void setProgressTaskId(ProgressTaskId taskId) {
     88    }
     89
     90    @Override
     91    public ProgressTaskId getProgressTaskId() {
     92        return null;
     93    }
    9594}
  • trunk/src/org/openstreetmap/josm/io/session/SessionReader.java

    r4702 r4718  
    55import static org.openstreetmap.josm.tools.Utils.equal;
    66
    7 import java.awt.Component;
    87import java.io.BufferedInputStream;
    9 import java.io.IOException;
    10 import java.io.InputStream;
    118import java.io.File;
    129import java.io.FileInputStream;
    1310import java.io.FileNotFoundException;
     11import java.io.IOException;
     12import java.io.InputStream;
    1413import java.lang.reflect.InvocationTargetException;
     14import java.net.URI;
     15import java.net.URISyntaxException;
    1516import java.util.ArrayList;
    1617import java.util.Collections;
     
    2526import java.util.zip.ZipException;
    2627import java.util.zip.ZipFile;
    27 import java.net.URI;
    28 import java.net.URISyntaxException;
    2928
    3029import javax.swing.JOptionPane;
     
    3433import javax.xml.parsers.ParserConfigurationException;
    3534
     35import org.openstreetmap.josm.Main;
     36import org.openstreetmap.josm.gui.ExtendedDialog;
     37import org.openstreetmap.josm.gui.layer.Layer;
     38import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
     39import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     40import org.openstreetmap.josm.io.IllegalDataException;
     41import org.openstreetmap.josm.tools.MultiMap;
     42import org.openstreetmap.josm.tools.Utils;
    3643import org.w3c.dom.Document;
    3744import org.w3c.dom.Element;
     
    3946import org.w3c.dom.NodeList;
    4047import org.xml.sax.SAXException;
    41 
    42 import org.openstreetmap.josm.Main;
    43 import org.openstreetmap.josm.gui.ExtendedDialog;
    44 import org.openstreetmap.josm.gui.layer.Layer;
    45 import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    46 import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
    47 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    48 import org.openstreetmap.josm.io.IllegalDataException;
    49 import org.openstreetmap.josm.tools.MultiMap;
    50 import org.openstreetmap.josm.tools.Utils;
    5148
    5249/**
     
    153150            File file = getFile(uriStr);
    154151            try {
    155                 if (file != null) {
     152                if (file != null)
    156153                    return new BufferedInputStream(new FileInputStream(file));
    157                 } else if (inZipPath != null) {
     154                else if (inZipPath != null) {
    158155                    ZipEntry entry = zipFile.getEntry(inZipPath);
    159156                    if (entry != null) {
     
    178175            try {
    179176                URI uri = new URI(uriStr);
    180                 if ("file".equals(uri.getScheme())) {
     177                if ("file".equals(uri.getScheme()))
    181178                    // absolute path
    182179                    return new File(uri);
    183                 } else if (uri.getScheme() == null) {
     180                else if (uri.getScheme() == null) {
    184181                    // Check if this is an absolute path without 'file:' scheme part.
    185182                    // At this point, (as an exception) platform dependent path separator will be recognized.
    186183                    // (This form is discouraged, only for users that like to copy and paste a path manually.)
    187184                    File file = new File(uriStr);
    188                     if (file.isAbsolute()) {
     185                    if (file.isAbsolute())
    189186                        return file;
    190                     } else {
     187                    else {
    191188                        // for relative paths, only forward slashes are permitted
    192189                        if (isZip()) {
     
    200197                                return null;
    201198                            }
    202                         } else {
     199                        } else
    203200                            return new File(sessionFile.toURI().resolve(uri));
    204                         }
    205                     }
    206                 } else {
     201                    }
     202                } else
    207203                    throw new IOException(tr("Unsupported scheme ''{0}'' in URI ''{1}''.", uri.getScheme(), uriStr));
    208                 }
    209204            } catch (URISyntaxException e) {
    210205                throw new IOException(e);
     
    328323                CancelOrContinueDialog dialog = new CancelOrContinueDialog();
    329324                dialog.show(
    330                     tr("Unable to load layer"),
    331                     tr("Cannot load layer of type ''{0}'' because no suitable importer was found.", type),
    332                     JOptionPane.WARNING_MESSAGE,
    333                     progressMonitor
    334                 );
     325                        tr("Unable to load layer"),
     326                        tr("Cannot load layer of type ''{0}'' because no suitable importer was found.", type),
     327                        JOptionPane.WARNING_MESSAGE,
     328                        progressMonitor
     329                        );
    335330                if (dialog.isCancel()) {
    336331                    progressMonitor.cancel();
     
    347342                        CancelOrContinueDialog dialog = new CancelOrContinueDialog();
    348343                        dialog.show(
    349                             tr("Unable to load layer"),
    350                             tr("Cannot load layer {0} because it depends on layer {1} which has been skipped.", idx, d),
    351                             JOptionPane.WARNING_MESSAGE,
    352                             progressMonitor
    353                         );
     344                                tr("Unable to load layer"),
     345                                tr("Cannot load layer {0} because it depends on layer {1} which has been skipped.", idx, d),
     346                                JOptionPane.WARNING_MESSAGE,
     347                                progressMonitor
     348                                );
    354349                        if (dialog.isCancel()) {
    355350                            progressMonitor.cancel();
     
    375370                    CancelOrContinueDialog dialog = new CancelOrContinueDialog();
    376371                    dialog.show(
    377                         tr("Error loading layer"),
    378                         tr("<html>Could not load layer {0} ''{1}''.<br>Error is:<br>{2}</html>", idx, name, exception.getMessage()),
    379                         JOptionPane.ERROR_MESSAGE,
    380                         progressMonitor
    381                     );
     372                            tr("Error loading layer"),
     373                            tr("<html>Could not load layer {0} ''{1}''.<br>Error is:<br>{2}</html>", idx, name, exception.getMessage()),
     374                            JOptionPane.ERROR_MESSAGE,
     375                            progressMonitor
     376                            );
    382377                    if (dialog.isCancel()) {
    383378                        progressMonitor.cancel();
     
    397392        for (Entry<Integer, Layer> e : layersMap.entrySet()) {
    398393            Layer l = e.getValue();
    399             if (l == null) continue;
     394            if (l == null) {
     395                continue;
     396            }
    400397            l.setName(names.get(e.getKey()));
    401398            layers.add(l);
     
    418415                SwingUtilities.invokeAndWait(new Runnable() {
    419416                    @Override public void run() {
    420                         Component parent;
    421                         if (progressMonitor instanceof PleaseWaitProgressMonitor) {
    422                             parent = ((PleaseWaitProgressMonitor) progressMonitor).getDialog();
    423                         } else {
    424                             parent = Main.parent;
    425                         }
    426417                        ExtendedDialog dlg = new ExtendedDialog(
    427                                 parent,
     418                                Main.parent,
    428419                                title,
    429420                                new String[] { tr("Cancel"), tr("Skip layer and continue") }
    430                         );
     421                                );
    431422                        dlg.setButtonIcons(new String[] {"cancel", "dialogs/next"});
    432423                        dlg.setIcon(icon);
Note: See TracChangeset for help on using the changeset viewer.