Changeset 2817 in josm for trunk

Timestamp:

2010-01-11T21:06:49+01:00 (15 years ago)

Author:

Gubaer

Message:

fixed #3063: Downloading a plugin yields 3 dialogs at the same time: Downloading plugin / You should restart JOSM / Plugin downloaded
fixed #3628: JOSM blocking itself updating broken plugin
fixed #4187: JOSM deleted random files from disk after start (data loss)
fixed #4199: new version - plugins update vs josm start [should be fixed. Be careful if you have two JOSM instances running. Auto-update of plugins in the second instance will fail because plugin files are locked by the first instance]
fixed #4034: JOSM should auto-download plugin list when it hasn't been downloaded before [JOSM now displays a hint]

fixed: splash screen showing again even if plugins are auto-updated
new: progress indication integrated in splash screen
new: cancelable, asynchronous download of plugins from preferences
new: cancelable, asynchronous download of plugin list from plugin download sites
new: asynchronous loading of plugin information, launch of preferences dialog accelerated
refactored: clean up, documentation of plugin management code (PluginHandler)

Location:

trunk/src/org/openstreetmap/josm

Files:

• Main.java (modified) (4 diffs)
• data/Preferences.java (modified) (2 diffs)
• gui/MainApplication.java (modified) (3 diffs)
• gui/SplashScreen.java (modified) (6 diffs)
• gui/preferences/PluginPreference.java (modified) (8 diffs)
• gui/preferences/PreferenceTabbedPane.java (modified) (3 diffs)
• gui/preferences/plugin (added)
• gui/preferences/plugin/PluginPreferencesModel.java (added)
• gui/preferences/plugin/PluginPreferencesPanel.java (added)
• io/CacheFiles.java (modified) (1 diff)
• plugins/Plugin.java (modified) (2 diffs)
• plugins/PluginDownloadException.java (added)
• plugins/PluginDownloadTask.java (added)
• plugins/PluginDownloader.java (deleted)
• plugins/PluginException.java (modified) (2 diffs)
• plugins/PluginHandler.java (modified) (8 diffs)
• plugins/PluginInformation.java (modified) (7 diffs)
• plugins/PluginListParseException.java (added)
• plugins/PluginListParser.java (added)
• plugins/PluginSelection.java (deleted)
• plugins/ReadLocalPluginInformationTask.java (added)
• plugins/ReadRemotePluginInformationTask.java (added)

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

@@ -47 +47 @@
 import org.openstreetmap.josm.gui.MainMenu;
 import org.openstreetmap.josm.gui.MapFrame;
-import org.openstreetmap.josm.gui.SplashScreen;
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
 import org.openstreetmap.josm.gui.io.SaveLayersDialog;
@@ -174 +173 @@
         Main.map = map;
 
-        PluginHandler.setMapFrame(old, map);
+        PluginHandler.notifyMapFrameChanged(old, map);
     }
 
@@ -192 +191 @@
 
     public Main() {
-        this(null);
-    }
-
-    public Main(SplashScreen splash) {
         main = this;
         //        platform = determinePlatformHook();
@@ -201 +196 @@
         contentPane.add(panel, BorderLayout.CENTER);
         panel.add(gettingStarted, BorderLayout.CENTER);
-
-        if(splash != null) {
-            splash.setStatus(tr("Creating main GUI"));
-        }
         menu = new MainMenu();
 

trunk/src/org/openstreetmap/josm/data/Preferences.java

@@ -202 +202 @@
     }
 
-    public File getPluginsDirFile() {
+    public File getPluginsDirectory() {
         return new File(getPreferencesDirFile(), "plugins");
     }
@@ -748 +748 @@
         System.setProperties(sysProp);
     }
+
+    /**
+     * The default plugin site
+     */
+    private final static String[] DEFAULT_PLUGIN_SITE = {"http://josm.openstreetmap.de/plugin"};
+
+    /**
+     * Replies the collection of plugin site URLs from where plugin lists can be downloaded
+     * 
+     * @return
+     */
+    public Collection<String> getPluginSites() {
+        return getCollection("pluginmanager.sites", Arrays.asList(DEFAULT_PLUGIN_SITE));
+    }
+
+    /**
+     * Sets the collection of plugin site URLs.
+     * 
+     * @param sites the site URLs
+     */
+    public void setPluginSites(Collection<String> sites) {
+        putCollection("pluginmanager.sites", sites);
+    }
+
 }

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

@@ -22 +22 @@
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.gui.preferences.server.OAuthAccessTokenHolder;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 import org.openstreetmap.josm.io.DefaultProxySelector;
 import org.openstreetmap.josm.io.auth.CredentialsManagerFactory;
 import org.openstreetmap.josm.io.auth.DefaultAuthenticator;
 import org.openstreetmap.josm.plugins.PluginHandler;
+import org.openstreetmap.josm.plugins.PluginInformation;
 import org.openstreetmap.josm.tools.BugReportExceptionHandler;
 import org.openstreetmap.josm.tools.I18n;
@@ -45 +47 @@
      * display the frame.
      */
-    public MainApplication(JFrame mainFrame, SplashScreen splash) {
-        super(splash);
+    public MainApplication(JFrame mainFrame) {
+        super();
         mainFrame.setContentPane(contentPane);
         mainFrame.setJMenuBar(menu);
@@ -151 +153 @@
         }
 
-        SplashScreen splash = new SplashScreen(Main.pref.getBoolean("draw.splashscreen", true));
-
-        splash.setStatus(tr("Activating updated plugins"));
-        PluginHandler.earlyCleanup();
-
-        splash.setStatus(tr("Loading early plugins"));
-        PluginHandler.loadPlugins(true);
-
-        splash.setStatus(tr("Setting defaults"));
+        SplashScreen splash = new SplashScreen();
+        ProgressMonitor monitor = splash.getProgressMonitor();
+        monitor.beginTask(tr("Initializing"));
+        monitor.setTicksCount(7);
+        splash.setVisible(Main.pref.getBoolean("draw.splashscreen", true));
+
+        List<PluginInformation> pluginsToLoad = PluginHandler.buildListOfPluginsToLoad(monitor.createSubTaskMonitor(1, false));
+        if (!pluginsToLoad.isEmpty() && PluginHandler.checkAndConfirmPluginUpdate()) {
+            monitor.subTask(tr("Updating plugins..."));
+            PluginHandler.updatePlugins(pluginsToLoad, monitor.createSubTaskMonitor(1, false));
+        }
+        monitor.worked(1);
+
+        monitor.subTask(tr("Installing updated plugins"));
+        PluginHandler.installDownloadedPlugins();
+        monitor.worked(1);
+
+        monitor.subTask(tr("Loading early plugins"));
+        PluginHandler.loadEarlyPlugins(pluginsToLoad, monitor.createSubTaskMonitor(1, false));
+        monitor.worked(1);
+
+        monitor.subTask(tr("Setting defaults"));
         preConstructorInit(args);
         removeObsoletePreferences();
-        splash.setStatus(tr("Creating main GUI"));
+        monitor.worked(1);
+
+        monitor.indeterminateSubTask(tr("Creating main GUI"));
         JFrame mainFrame = new JFrame(tr("Java OpenStreetMap Editor"));
         Main.parent = mainFrame;
-        final Main main = new MainApplication(mainFrame, splash);
-        splash.setStatus(tr("Loading plugins"));
-        PluginHandler.loadPlugins(false);
+        final Main main = new MainApplication(mainFrame);
+        monitor.worked(1);
+
+        monitor.subTask(tr("Loading plugins"));
+        PluginHandler.loadLatePlugins(pluginsToLoad,  monitor.createSubTaskMonitor(1, false));
+        monitor.worked(1);
         toolbar.refreshToolbarControl();
-
+        splash.setVisible(false);
+        splash.dispose();
         mainFrame.setVisible(true);
-        splash.closeSplash();
 
         if (((!args.containsKey("no-maximize") && !args.containsKey("geometry")

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

@@ -4 +4 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 
-import java.awt.AWTEvent;
 import java.awt.Color;
 import java.awt.Dimension;
@@ -12 +11 @@
 import java.awt.Insets;
 import java.awt.Toolkit;
-import java.awt.event.AWTEventListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
@@ -18 +16 @@
 import javax.swing.JLabel;
 import javax.swing.JPanel;
+import javax.swing.JProgressBar;
 import javax.swing.JSeparator;
 import javax.swing.JWindow;
-import javax.swing.SwingUtilities;
 import javax.swing.border.Border;
 import javax.swing.border.EmptyBorder;
 import javax.swing.border.EtchedBorder;
 
-import org.openstreetmap.josm.actions.AboutAction;
 import org.openstreetmap.josm.data.Version;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.gui.progress.ProgressRenderer;
+import org.openstreetmap.josm.gui.progress.SwingRenderingProgressMonitor;
 import org.openstreetmap.josm.tools.ImageProvider;
 
@@ -32 +32 @@
  * Show a splash screen so the user knows what is happening during startup.
  *
- * @author cbrill
  */
 public class SplashScreen extends JWindow {
 
-    private JLabel status;
-    private boolean visible;
+    private SplashScreenProgressRenderer progressRenderer;
+    private SwingRenderingProgressMonitor progressMonitor;
 
-    private Runnable closerRunner;
-
-    public SplashScreen(boolean visible) {
+    public SplashScreen() {
         super();
-        this.visible=visible;
-
-        if (!visible)
-            return;
 
         // Add a nice border to the main splash screen
@@ -89 +82 @@
 
         // Add a status message
-        status = new JLabel();
+        progressRenderer = new SplashScreenProgressRenderer();
         gbc.gridy = 3;
-        gbc.insets = new Insets(0, 0, 0, 0);
-        innerContentPane.add(status, gbc);
-        setStatus(tr("Initializing"));
+        gbc.insets = new Insets(5, 5, 10, 5);
+        innerContentPane.add(progressRenderer, gbc);
+        progressMonitor = new SwingRenderingProgressMonitor(progressRenderer);
 
         pack();
@@ -103 +96 @@
                 screenSize.height / 2 - (labelSize.height / 2));
 
-        // Method to close the splash screen when being clicked or when closeSplash is called
-        closerRunner = new Runnable() {
-            public void run() {
-                setVisible(false);
-                dispose();
-            }
-        };
-
         // Add ability to hide splash screen by clicking it
         addMouseListener(new MouseAdapter() {
+            @Override
             public void mousePressed(MouseEvent event) {
-                try {
-                    closerRunner.run();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    // can catch InvocationTargetException
-                    // can catch InterruptedException
-                }
+                setVisible(false);
             }
         });
-
-        // Hide splashscreen when other window is created
-        Toolkit.getDefaultToolkit().addAWTEventListener(awtListener, AWTEvent.WINDOW_EVENT_MASK);
-
-        setVisible(true);
     }
 
-    private AWTEventListener awtListener = new AWTEventListener() {
-        public void eventDispatched(AWTEvent event) {
-            if (event.getSource() != SplashScreen.this) {
-                closeSplash();
-            }
-        }
-    };
-
-    /**
-     * This method sets the status message. It should be called prior to
-     * actually doing the action.
-     *
-     * @param message
-     *            the message to be displayed
-     */
-    public void setStatus(String message) {
-        if (!visible)
-            return;
-        status.setText(message + "...");
+    public ProgressMonitor getProgressMonitor() {
+        return progressMonitor;
     }
 
-    /**
-     * Closes the splashscreen. Call once you are done starting.
-     */
-    public void closeSplash() {
-        if (!visible)
-            return;
-        Toolkit.getDefaultToolkit().removeAWTEventListener(awtListener);
-        try {
-            SwingUtilities.invokeLater(closerRunner);
-        } catch (Exception e) {
-            e.printStackTrace();
-            // can catch InvocationTargetException
-            // can catch InterruptedException
+    static private class SplashScreenProgressRenderer extends JPanel implements ProgressRenderer {
+        private JLabel lblTaskTitle;
+        private JLabel lblCustomText;
+        private JProgressBar progressBar;
+
+        protected void build() {
+            setLayout(new GridBagLayout());
+            GridBagConstraints gc = new GridBagConstraints();
+            gc.gridx = 0;
+            gc.gridy = 0;
+            gc.fill = GridBagConstraints.HORIZONTAL;
+            gc.weightx = 1.0;
+            gc.weighty = 0.0;
+            gc.insets = new Insets(5,0,0,5);
+            add(lblTaskTitle = new JLabel(""), gc);
+
+            gc.gridx = 0;
+            gc.gridy = 1;
+            gc.fill = GridBagConstraints.HORIZONTAL;
+            gc.weightx = 1.0;
+            gc.weighty = 0.0;
+            gc.insets = new Insets(5,0,0,5);
+            add(lblCustomText = new JLabel(""), gc);
+
+            gc.gridx = 0;
+            gc.gridy = 2;
+            gc.fill = GridBagConstraints.HORIZONTAL;
+            gc.weightx = 1.0;
+            gc.weighty = 0.0;
+            gc.insets = new Insets(5,0,0,5);
+            add(progressBar = new JProgressBar(JProgressBar.HORIZONTAL), gc);
+        }
+
+        public SplashScreenProgressRenderer() {
+            build();
+        }
+
+        public void setCustomText(String message) {
+            lblCustomText.setText(message);
+            repaint();
+        }
+
+        public void setIndeterminate(boolean indeterminate) {
+            progressBar.setIndeterminate(indeterminate);
+            repaint();
+        }
+
+        public void setMaximum(int maximum) {
+            progressBar.setMaximum(maximum);
+            repaint();
+        }
+
+        public void setTaskTitle(String taskTitle) {
+            lblTaskTitle.setText(taskTitle);
+            repaint();
+        }
+
+        public void setValue(int value) {
+            progressBar.setValue(value);
+            repaint();
         }
     }

trunk/src/org/openstreetmap/josm/gui/preferences/PluginPreference.java

@@ -3 +3 @@
 
 import static org.openstreetmap.josm.tools.I18n.tr;
-
-import java.awt.Dimension;
+import static org.openstreetmap.josm.tools.I18n.trn;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.FlowLayout;
+import java.awt.GridBagConstraints;
 import java.awt.GridBagLayout;
-import java.awt.Rectangle;
+import java.awt.Insets;
 import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
 import java.util.Collection;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Logger;
 
 import javax.swing.AbstractAction;
+import javax.swing.BorderFactory;
 import javax.swing.DefaultListModel;
 import javax.swing.JButton;
 import javax.swing.JLabel;
 import javax.swing.JList;
-import javax.swing.JTextField;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
-import javax.swing.Scrollable;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
 import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.plugins.PluginDownloader;
-import org.openstreetmap.josm.plugins.PluginSelection;
+import org.openstreetmap.josm.gui.HelpAwareOptionPane;
+import org.openstreetmap.josm.gui.help.HelpUtil;
+import org.openstreetmap.josm.gui.preferences.plugin.PluginPreferencesModel;
+import org.openstreetmap.josm.gui.preferences.plugin.PluginPreferencesPanel;
+import org.openstreetmap.josm.gui.widgets.SelectAllOnFocusGainedDecorator;
+import org.openstreetmap.josm.plugins.PluginDownloadTask;
+import org.openstreetmap.josm.plugins.PluginInformation;
+import org.openstreetmap.josm.plugins.ReadLocalPluginInformationTask;
+import org.openstreetmap.josm.plugins.ReadRemotePluginInformationTask;
 import org.openstreetmap.josm.tools.GBC;
+import org.openstreetmap.josm.tools.ImageProvider;
 
 public class PluginPreference implements PreferenceSetting {
+    private final static Logger logger = Logger.getLogger(PluginPreference.class.getName());
 
     public static class Factory implements PreferenceSettingFactory {
@@ -38 +59 @@
     }
 
-    private JPanel plugin;
-    private JPanel pluginPanel = new NoHorizontalScrollPanel(new GridBagLayout());
-    private PreferenceTabbedPane gui;
-    private JScrollPane pluginPane;
-    private PluginSelection selection = new PluginSelection();
-    private JTextField txtFilter;
+    public static String buildDownloadSummary(PluginDownloadTask task) {
+        Collection<PluginInformation> downloaded = task.getDownloadedPlugins();
+        Collection<PluginInformation> failed = task.getFailedPlugins();
+        StringBuilder sb = new StringBuilder();
+        if (! downloaded.isEmpty()) {
+            sb.append(trn(
+                    "The following plugin has been downloaded <strong>successfully</strong>:",
+                    "The following {0} plugins have been downloaded successfully:",
+                    downloaded.size(),
+                    downloaded.size()
+            ));
+            sb.append("<ul>");
+            for(PluginInformation pi: downloaded) {
+                sb.append("<li>").append(pi.name).append("</li>");
+            }
+            sb.append("</ul>");
+        }
+        if (! failed.isEmpty()) {
+            sb.append(trn(
+                    "Downloading the following plugin has <strong>failed</strong>:",
+                    "Downloading the following {0} plugins has <strong>failed</strong>:",
+                    failed.size(),
+                    failed.size()
+            ));
+            sb.append("<ul>");
+            for(PluginInformation pi: failed) {
+                sb.append("<li>").append(pi.name).append("</li>");
+            }
+            sb.append("</ul>");
+        }
+        return sb.toString();
+    }
+
+    private JTextField tfFilter;
+    private PluginPreferencesPanel pnlPluginPreferences;
+    private PluginPreferencesModel model;
+    private JScrollPane spPluginPreferences;
+
+    protected JPanel buildSearchFieldPanel() {
+        JPanel pnl  = new JPanel(new GridBagLayout());
+        pnl.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
+        GridBagConstraints gc = new GridBagConstraints();
+
+        gc.anchor = GridBagConstraints.NORTHWEST;
+        gc.fill = GridBagConstraints.HORIZONTAL;
+        gc.weightx = 0.0;
+        gc.insets = new Insets(0,0,0,3);
+        pnl.add(new JLabel(tr("Search:")), gc);
+
+        gc.gridx = 1;
+        gc.weightx = 1.0;
+        pnl.add(tfFilter = new JTextField(), gc);
+        tfFilter.setToolTipText(tr("Enter a search expression"));
+        SelectAllOnFocusGainedDecorator.decorate(tfFilter);
+        tfFilter.getDocument().addDocumentListener(new SearchFieldAdapter());
+        return pnl;
+    }
+
+    protected JPanel buildActionPanel() {
+        JPanel pnl = new JPanel(new FlowLayout(FlowLayout.CENTER));
+
+        pnl.add(new JButton(new DownloadAvailablePluginsAction()));
+        pnl.add(new JButton(new UpdateSelectedPluginsAction()));
+        pnl.add(new JButton(new ConfigureSitesAction()));
+        return pnl;
+    }
+
+    protected JPanel buildContentPane() {
+        JPanel pnl = new JPanel(new BorderLayout());
+        pnl.add(buildSearchFieldPanel(), BorderLayout.NORTH);
+        model  = new PluginPreferencesModel();
+        spPluginPreferences = new JScrollPane(pnlPluginPreferences = new PluginPreferencesPanel(model));
+        spPluginPreferences.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
+        spPluginPreferences.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+        spPluginPreferences.getVerticalScrollBar().addComponentListener(
+                new ComponentAdapter(){
+                    @Override
+                    public void componentShown(ComponentEvent e) {
+                        spPluginPreferences.setBorder(UIManager.getBorder("ScrollPane.border"));
+                    }
+                    @Override
+                    public void componentHidden(ComponentEvent e) {
+                        spPluginPreferences.setBorder(null);
+                    }
+                }
+        );
+
+        pnl.add(spPluginPreferences, BorderLayout.CENTER);
+        pnl.add(buildActionPanel(), BorderLayout.SOUTH);
+        return pnl;
+    }
 
     public void addGui(final PreferenceTabbedPane gui) {
-        this.gui = gui;
-        plugin = gui.createPreferenceTab("plugin", tr("Plugins"), tr("Configure available plugins."), false);
-
-        txtFilter = new JTextField();
-        JLabel lbFilter = new JLabel(tr("Search: "));
-        lbFilter.setLabelFor(txtFilter);
-        plugin.add(lbFilter);
-        plugin.add(txtFilter, GBC.eol().fill(GBC.HORIZONTAL));
-        txtFilter.getDocument().addDocumentListener(new DocumentListener(){
-            public void changedUpdate(DocumentEvent e) {
-                action();
-            }
-
-            public void insertUpdate(DocumentEvent e) {
-                action();
-            }
-
-            public void removeUpdate(DocumentEvent e) {
-                action();
-            }
-
-            private void action() {
-                selection.drawPanel(pluginPanel);
-            }
-        });
-        plugin.add(GBC.glue(0,10), GBC.eol());
-
-        /* main plugin area */
-        pluginPane = new JScrollPane(pluginPanel, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
-        pluginPane.setBorder(null);
-        plugin.add(pluginPane, GBC.eol().fill(GBC.BOTH));
-        plugin.add(GBC.glue(0,10), GBC.eol());
-
-        /* buttons at the bottom */
-        JButton morePlugins = new JButton(tr("Download List"));
-        morePlugins.addActionListener(new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                selection.updateDescription(pluginPanel);
-            }
-        });
-        plugin.add(morePlugins, GBC.std().insets(0,0,10,0));
-
-        JButton update = new JButton(tr("Update"));
-        update.addActionListener(new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                selection.update(pluginPanel);
-            }
-        });
-        plugin.add(update, GBC.std().insets(0,0,10,0));
-
-        JButton configureSites = new JButton(tr("Configure Sites..."));
-        configureSites.addActionListener(new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                configureSites();
-            }
-        });
-        plugin.add(configureSites, GBC.std());
-
-        selection.passTxtFilter(txtFilter);
-        selection.loadPlugins();
-        selection.drawPanel(pluginPanel);
+        GridBagConstraints gc = new GridBagConstraints();
+        gc.weightx = 1.0;
+        gc.weighty = 1.0;
+        gc.anchor = GridBagConstraints.NORTHWEST;
+        gc.fill = GridBagConstraints.BOTH;
+        gui.plugins.add(buildContentPane(), gc);
+        pnlPluginPreferences.refreshView();
+        gui.addChangeListener(new PluginPreferenceActivationListener(gui.plugins));
     }
 
@@ -113 +166 @@
         p.add(new JLabel(tr("Add JOSM Plugin description URL.")), GBC.eol());
         final DefaultListModel model = new DefaultListModel();
-        for (String s : PluginDownloader.getSites()) {
+        for (String s : Main.pref.getPluginSites()) {
             model.addElement(s);
         }
@@ -122 +175 @@
             public void actionPerformed(ActionEvent e) {
                 String s = JOptionPane.showInputDialog(
-                        gui,
+                        JOptionPane.getFrameForComponent(pnlPluginPreferences),
                         tr("Add JOSM Plugin description URL."),
                         tr("Enter URL"),
@@ -136 +189 @@
                 if (list.getSelectedValue() == null) {
                     JOptionPane.showMessageDialog(
-                            gui,
+                            JOptionPane.getFrameForComponent(pnlPluginPreferences),
                             tr("Please select an entry."),
                             tr("Warning"),
@@ -159 +212 @@
                 if (list.getSelectedValue() == null) {
                     JOptionPane.showMessageDialog(
-                            gui,
+                            JOptionPane.getFrameForComponent(pnlPluginPreferences),
                             tr("Please select an entry."),
                             tr("Warning"),
@@ -171 +224 @@
         p.add(buttons, GBC.eol());
         int answer = JOptionPane.showConfirmDialog(
-                gui,
+                JOptionPane.getFrameForComponent(pnlPluginPreferences),
                 p,
                 tr("Configure Plugin Sites"), JOptionPane.OK_CANCEL_OPTION,
@@ -181 +234 @@
             sites.add((String)model.getElementAt(i));
         }
-        PluginDownloader.setSites(sites);
+        Main.pref.setPluginSites(sites);
+    }
+
+    /**
+     * Replies the list of plugins waiting for update or download
+     * 
+     * @return the list of plugins waiting for update or download
+     */
+    public List<PluginInformation> getPluginsScheduledForUpdateOrDownload() {
+        return model.getPluginsScheduledForUpdateOrDownload();
     }
 
     public boolean ok() {
-        return selection.finish();
-    }
-
-    private static class NoHorizontalScrollPanel extends JPanel implements Scrollable {
-        public NoHorizontalScrollPanel(GridBagLayout gridBagLayout) {
-            super(gridBagLayout);
-        }
-
-        public Dimension getPreferredScrollableViewportSize() {
-            return super.getPreferredSize();
-        }
-
-        public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
-            return 30;
-        }
-
-        public boolean getScrollableTracksViewportHeight() {
-            return false;
-        }
-
-        public boolean getScrollableTracksViewportWidth() {
+        if (model.isActivePluginsChanged()) {
+            Main.pref.putCollection("plugins", model.getSelectedPluginNames());
             return true;
         }
-
-        public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
-            return 10;
+        return false;
+    }
+
+    public void readLocalPluginInformation() {
+        final ReadLocalPluginInformationTask task = new ReadLocalPluginInformationTask();
+        Runnable r = new Runnable() {
+            public void run() {
+                if (task.isCanceled()) return;
+                SwingUtilities.invokeLater(new Runnable() {
+                    public void run() {
+                        model.setAvailablePlugins(task.getAvailablePlugins());
+                        pnlPluginPreferences.refreshView();
+                    }
+                });
+            };
+        };
+        Main.worker.submit(task);
+        Main.worker.submit(r);
+    }
+
+    /**
+     * The action for downloading the list of available plugins
+     *
+     */
+    class DownloadAvailablePluginsAction extends AbstractAction {
+
+        public DownloadAvailablePluginsAction() {
+            putValue(NAME,tr("Download list"));
+            putValue(SHORT_DESCRIPTION, tr("Download the list of available plugins"));
+            putValue(SMALL_ICON, ImageProvider.get("download"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            final ReadRemotePluginInformationTask task = new ReadRemotePluginInformationTask(Main.pref.getPluginSites());
+            Runnable continuation = new Runnable() {
+                public void run() {
+                    if (task.isCanceled()) return;
+                    SwingUtilities.invokeLater(new Runnable() {
+                        public void run() {
+                            model.setAvailablePlugins(task.getAvailabePlugins());
+                            pnlPluginPreferences.refreshView();
+
+                        }
+                    });
+                }
+            };
+            Main.worker.submit(task);
+            Main.worker.submit(continuation);
+        }
+    }
+
+    /**
+     * The action for downloading the list of available plugins
+     *
+     */
+    class UpdateSelectedPluginsAction extends AbstractAction {
+        public UpdateSelectedPluginsAction() {
+            putValue(NAME,tr("Update plugins"));
+            putValue(SHORT_DESCRIPTION, tr("Update the selected plugins"));
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "refresh"));
+        }
+
+        protected void notifyDownloadResults(PluginDownloadTask task) {
+            Collection<PluginInformation> downloaded = task.getDownloadedPlugins();
+            Collection<PluginInformation> failed = task.getFailedPlugins();
+            StringBuilder sb = new StringBuilder();
+            sb.append("<html>");
+            sb.append(buildDownloadSummary(task));
+            if (!downloaded.isEmpty()) {
+                sb.append("Please restart JOSM to activate the downloaded plugins.");
+            }
+            sb.append("</html>");
+            HelpAwareOptionPane.showOptionDialog(
+                    pnlPluginPreferences,
+                    sb.toString(),
+                    tr("Update plugins"),
+                    failed.isEmpty() ? JOptionPane.WARNING_MESSAGE : JOptionPane.INFORMATION_MESSAGE,
+                            // FIXME: check help topic
+                            HelpUtil.ht("/Preferences/Plugin")
+            );
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            List<PluginInformation> toUpdate = model.getSelectedPlugins();
+            final PluginDownloadTask task = new PluginDownloadTask(
+                    pnlPluginPreferences,
+                    toUpdate,
+                    tr("Update plugins")
+            );
+            Runnable r = new Runnable() {
+                public void run() {
+                    if (task.isCanceled())
+                        return;
+                    notifyDownloadResults(task);
+                    model.refreshLocalPluginVersion(task.getDownloadedPlugins());
+                    pnlPluginPreferences.refreshView();
+                }
+            };
+            Main.worker.submit(task);
+            Main.worker.submit(r);
+        }
+    }
+
+
+    /**
+     * The action for configuring the plugin download sites
+     *
+     */
+    class ConfigureSitesAction extends AbstractAction {
+        public ConfigureSitesAction() {
+            putValue(NAME,tr("Configure sites..."));
+            putValue(SHORT_DESCRIPTION, tr("Configure the list of sites where plugins are downloaded from"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            configureSites();
+        }
+    }
+
+    /**
+     * Listens to the activation of the plugin preferences tab. On activation it
+     * reloads plugin information from the local file system.
+     *
+     */
+    class PluginPreferenceActivationListener implements ChangeListener {
+        private Component pane;
+        public PluginPreferenceActivationListener(Component preferencesPane) {
+            pane = preferencesPane;
+        }
+
+        public void stateChanged(ChangeEvent e) {
+            JTabbedPane tp = (JTabbedPane)e.getSource();
+            if (tp.getSelectedComponent() == pane) {
+                readLocalPluginInformation();
+            }
+        }
+    }
+
+    /**
+     * Applies the current filter condition in the filter text field to the
+     * model
+     */
+    class SearchFieldAdapter implements DocumentListener {
+        public void filter() {
+            String expr = tfFilter.getText().trim();
+            if (expr.equals("")) {
+                expr = null;
+            }
+            model.filterDisplayedPlugins(expr);
+            pnlPluginPreferences.refreshView();
+        }
+
+        public void changedUpdate(DocumentEvent arg0) {
+            filter();
+        }
+
+        public void insertUpdate(DocumentEvent arg0) {
+            filter();
+        }
+
+        public void removeUpdate(DocumentEvent arg0) {
+            filter();
         }
     }

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

@@ -23 +23 @@
 import javax.swing.JScrollPane;
 import javax.swing.JTabbedPane;
+import javax.swing.SwingUtilities;
 
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.plugins.PluginDownloadTask;
 import org.openstreetmap.josm.plugins.PluginHandler;
+import org.openstreetmap.josm.plugins.PluginInformation;
 import org.openstreetmap.josm.tools.BugReportExceptionHandler;
 import org.openstreetmap.josm.tools.GBC;
@@ -47 +50 @@
     public final JPanel map = createPreferenceTab("map", I18n.tr("Map Settings"), I18n.tr("Settings for the map projection and data interpretation."));
     public final JPanel audio = createPreferenceTab("audio", I18n.tr("Audio Settings"), I18n.tr("Settings for the audio player and audio markers."));
+    public final JPanel plugins = createPreferenceTab("plugin", tr("Plugins"), tr("Configure available plugins."), false);
 
     public final javax.swing.JTabbedPane displaycontent = new javax.swing.JTabbedPane();
@@ -95 +99 @@
     }
 
+    protected PluginPreference getPluginPreference() {
+        for (PreferenceSetting setting: settings) {
+            if (setting instanceof PluginPreference)
+                return (PluginPreference) setting;
+        }
+        return null;
+    }
+
     public void savePreferences() {
-        boolean requiresRestart = false;
-        for (PreferenceSetting setting : settings)
-        {
-            if(setting.ok()) {
-                requiresRestart = true;
+
+        // create a task for downloading plugins if the user has activated, yet not downloaded,
+        // new plugins
+        //
+        final PluginPreference preference = getPluginPreference();
+        final List<PluginInformation> toDownload = preference.getPluginsScheduledForUpdateOrDownload();
+        final PluginDownloadTask task;
+        if (! toDownload.isEmpty()) {
+            task = new PluginDownloadTask(this, toDownload, tr("Download plugins"));
+        } else {
+            task = null;
+        }
+
+        // this is the task which will run *after* the plugins are downloaded
+        //
+        final Runnable continuation = new Runnable() {
+            public void run() {
+                boolean requiresRestart = false;
+                if (task != null && !task.isCanceled()) {
+                    if (!task.getDownloadedPlugins().isEmpty()) {
+                        requiresRestart = true;
+                    }
+                }
+
+                for (PreferenceSetting setting : settings) {
+                    if (setting.ok()) {
+                        requiresRestart = true;
+                    }
+                }
+
+                // build the messages. We only display one message, including the status
+                // information from the plugin download task and - if necessary - a hint
+                // to restart JOSM
+                //
+                StringBuffer sb = new StringBuffer();
+                sb.append("<html>");
+                if (task != null && !task.isCanceled()) {
+                    sb.append(PluginPreference.buildDownloadSummary(task));
+                }
+                if (requiresRestart) {
+                    sb.append(tr("You have to restart JOSM for some settings to take effect."));
+                }
+                sb.append("</html>");
+
+                // display the message, if necessary
+                //
+                if ((task != null && !task.isCanceled()) || requiresRestart) {
+                    JOptionPane.showMessageDialog(
+                            Main.parent,
+                            sb.toString(),
+                            tr("Warning"),
+                            JOptionPane.WARNING_MESSAGE
+                    );
+                }
+                Main.parent.repaint();
             }
-        }
-        if (requiresRestart) {
-            JOptionPane.showMessageDialog(
-                    Main.parent,
-                    tr("You have to restart JOSM for some settings to take effect."),
-                    tr("Warning"),
-                    JOptionPane.WARNING_MESSAGE
+        };
+
+        if (task != null) {
+            // if we have to launch a plugin download task we do it asynchronously, followed
+            // by the remaining "save preferences" activites run on the Swing EDT.
+            //
+            Main.worker.submit(task);
+            Main.worker.submit(
+                    new Runnable() {
+                        public void run() {
+                            SwingUtilities.invokeLater(continuation);
+                        }
+                    }
             );
-        }
-        Main.parent.repaint();
+        } else {
+            // no need for asynchronous activities. Simply run the remaining "save preference"
+            // activities on this thread (we are already on the Swing EDT
+            //
+            continuation.run();
+        }
     }
 

trunk/src/org/openstreetmap/josm/io/CacheFiles.java

@@ -59 +59 @@
 
     public CacheFiles(String ident, boolean isPlugin) {
-        String pref = isPlugin ? Main.pref.getPluginsDirFile().getPath() : Main.pref.getPreferencesDir();
+        String pref = isPlugin ? Main.pref.getPluginsDirectory().getPath() : Main.pref.getPreferencesDir();
 
         boolean dir_writeable;

trunk/src/org/openstreetmap/josm/plugins/Plugin.java

@@ -53 +53 @@
      */
     public final String getPluginDir() {
-        return new File(Main.pref.getPluginsDirFile(), info.name).getPath();
+        return new File(Main.pref.getPluginsDirectory(), info.name).getPath();
     }
 
@@ -81 +81 @@
         String pluginDirName = Main.pref.getPreferencesDir()+"plugins/"+info.name+"/";
         File pluginDir = new File(pluginDirName);
-        if (!pluginDir.exists())
+        if (!pluginDir.exists()) {
             pluginDir.mkdirs();
+        }
         FileOutputStream out = new FileOutputStream(pluginDirName+to);
         InputStream in = getClass().getResourceAsStream(from);
         byte[] buffer = new byte[8192];
-        for(int len = in.read(buffer); len > 0; len = in.read(buffer))
+        for(int len = in.read(buffer); len > 0; len = in.read(buffer)) {
             out.write(buffer, 0, len);
+        }
         in.close();
         out.close();

trunk/src/org/openstreetmap/josm/plugins/PluginException.java

@@ -11 +11 @@
  * @author Immanuel.Scholz
  */
-public class PluginException extends RuntimeException {
+public class PluginException extends Exception {
     public final PluginProxy plugin;
     public final String name;
@@ -20 +20 @@
         this.name = name;
     }
+
+    public PluginException(String name, String message) {
+        super(message);
+        this.plugin = null;
+        this.name = name;
+    }
+
+    public PluginException(String name, Throwable cause) {
+        super(tr("An error occurred in plugin {0}", name), cause);
+        this.plugin = null;
+        this.name = name;
+    }
 }

trunk/src/org/openstreetmap/josm/plugins/PluginHandler.java

@@ -4 +4 @@
 import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
 import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trn;
 
 import java.awt.Font;
 import java.awt.GridBagLayout;
 import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.FilenameFilter;
 import java.net.URL;
 import java.net.URLClassLoader;
@@ -14 +17 @@
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.SortedMap;
-import java.util.TreeMap;
+import java.util.Map;
+import java.util.Set;
 import java.util.Map.Entry;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 import javax.swing.AbstractAction;
@@ -37 +48 @@
 import org.openstreetmap.josm.gui.download.DownloadSelection;
 import org.openstreetmap.josm.gui.preferences.PreferenceSettingFactory;
+import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.tools.CheckParameterUtil;
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.ImageProvider;
 
+/**
+ * PluginHandler is basically a collection of static utility functions used to bootstrap
+ * and manage the loaded plugins.
+ * 
+ */
 public class PluginHandler {
 
-    public static String [] oldplugins = new String[] {"mappaint", "unglueplugin",
-                "lang-de", "lang-en_GB", "lang-fr", "lang-it", "lang-pl", "lang-ro",
-                "lang-ru", "ewmsplugin", "ywms", "tways-0.2", "geotagged", "landsat",
-                "namefinder", "waypoints", "slippy_map_chooser", "tcx-support", "usertools",
-                "AgPifoJ", "utilsplugin"};
-    public static String [] unmaintained = new String[] {"gpsbabelgui", "Intersect_way"};
+    final public static String [] DEPRECATED_PLUGINS = new String[] {"mappaint", "unglueplugin",
+        "lang-de", "lang-en_GB", "lang-fr", "lang-it", "lang-pl", "lang-ro",
+        "lang-ru", "ewmsplugin", "ywms", "tways-0.2", "geotagged", "landsat",
+        "namefinder", "waypoints", "slippy_map_chooser", "tcx-support", "usertools",
+        "AgPifoJ", "utilsplugin"};
+
+    final public static String [] UNMAINTAINED_PLUGINS = new String[] {"gpsbabelgui", "Intersect_way"};
 
     /**
@@ -53 +73 @@
      */
     public final static Collection<PluginProxy> pluginList = new LinkedList<PluginProxy>();
-    /**
-     * Load all plugins specified in preferences. If the parameter is
-     * <code>true</code>, all early plugins are loaded (before constructor).
-     */
-    public static void loadPlugins(boolean early) {
-        List<String> plugins = new LinkedList<String>();
-        Collection<String> cp = Main.pref.getCollection("plugins", null);
-        if (cp != null) {
-            plugins.addAll(cp);
-        }
-        if (System.getProperty("josm.plugins") != null) {
-            plugins.addAll(Arrays.asList(System.getProperty("josm.plugins").split(",")));
-        }
-
-        for (String p : oldplugins) {
+
+
+    /**
+     * Removes deprecated plugins from a collection of plugins. Modifies the
+     * collection <code>plugins</code>.
+     * 
+     * Also notifies the user about removed deprecated plugins
+     * 
+     * @param plugins the collection of plugins
+     */
+    private static void filterDeprecatedPlugins(Collection<String> plugins) {
+        Set<String> removedPlugins = new HashSet<String>();
+        for (String p : DEPRECATED_PLUGINS) {
             if (plugins.contains(p)) {
                 plugins.remove(p);
                 Main.pref.removeFromCollection("plugins", p);
-                JOptionPane.showMessageDialog(
-                        Main.parent,
-                        tr("Plugin {0} is no longer necessary and has been deactivated.", p),
-                        tr("Warning"),
-                        JOptionPane.WARNING_MESSAGE
-                );
-            }
-        }
-        if(early)
-        {
-            for (String p : unmaintained) {
-                if (plugins.contains(p) && disablePlugin(tr("<html>Loading of {0} plugin was requested."
-                        +"<br>This plugin is no longer developed and very likely will produce errors."
-                        +"<br>It should be disabled.<br>Delete from preferences?</html>", p), p)) {
-                    plugins.remove(p);
-                }
-            }
-        }
-
-        if (plugins.isEmpty())
+                removedPlugins.add(p);
+            }
+        }
+        if (removedPlugins.isEmpty())
             return;
 
-        if(early)
-        {
-            String doUpdate = null;
-            String check = null;
-            int v = Version.getInstance().getVersion();
-            if(Main.pref.getInteger("pluginmanager.version", 0) < v)
-            {
-                doUpdate = tr("You updated your JOSM software.\nTo prevent problems the plugins should be updated as well.\n"
-                        + "Update plugins now?");
-                check = "pluginmanger.version";
-            }
-            else
-            {
-                long tim = System.currentTimeMillis();
-                long last = Main.pref.getLong("pluginmanager.lastupdate", 0);
-                Integer maxTime = Main.pref.getInteger("pluginmanager.warntime", 60);
-                long d = (tim - last)/(24*60*60*1000l);
-                if ((last <= 0) || (maxTime <= 0)) {
-                    Main.pref.put("pluginmanager.lastupdate",Long.toString(tim));
-                } else if (d > maxTime) {
-                    doUpdate = tr("Last plugin update more than {0} days ago.", d);
-                    check = "pluginmanager.time";
-                }
-            }
-            if(doUpdate != null)
-            {
-                ExtendedDialog dialog = new ExtendedDialog(
-                        Main.parent,
-                        tr("Update plugins"),
-                        new String[] {tr("Update plugins"), tr("Skip update")}
-                );
-                dialog.setContent(doUpdate);
-                dialog.toggleEnable(check);
-                dialog.setButtonIcons( new String[] {"dialogs/refresh.png", "cancel.png"});
-                dialog.configureContextsensitiveHelp(ht("/Plugin/AutomaticUpdate"), true /* show help button */);
-                dialog.showDialog();
-                if(dialog.getValue() == 1) {
-                    new PluginSelection().update();
-                }
-            }
-        }
-
-        SortedMap<Integer, Collection<PluginInformation>> p = new TreeMap<Integer, Collection<PluginInformation>>();
-        for (String pluginName : plugins) {
-            PluginInformation info = PluginInformation.findPlugin(pluginName);
-            if (info != null) {
-                if (info.early != early) {
-                    continue;
-                }
-                int josmVersion = Version.getInstance().getVersion();
-                if (info.mainversion > josmVersion && josmVersion != Version.JOSM_UNKNOWN_VERSION) {
-                    JOptionPane.showMessageDialog(
-                            Main.parent,
-                            tr("Plugin {0} requires JOSM update to version {1}.", pluginName,
-                                    info.mainversion),
-                                    tr("Warning"),
-                                    JOptionPane.WARNING_MESSAGE
-                    );
-                    continue;
-                }
-
-                if(info.requires != null)
-                {
-                    String warn = null;
-                    for(String n : info.requires.split(";"))
-                    {
-                        if(!plugins.contains(n))
-                        { warn = n; break; }
-                    }
-                    if(warn != null)
-                    {
-                        JOptionPane.showMessageDialog(Main.parent,
-                                tr("Plugin {0} is required by plugin {1} but was not found.",
-                                        warn, pluginName),
-                                        tr("Error"),
-                                        JOptionPane.ERROR_MESSAGE
-                        );
-                        continue;
-                    }
-                }
-                if (!p.containsKey(info.stage)) {
-                    p.put(info.stage, new LinkedList<PluginInformation>());
-                }
-                p.get(info.stage).add(info);
-            } else if(early) {
-                JOptionPane.showMessageDialog(
-                        Main.parent,
-                        tr("Plugin not found: {0}.", pluginName),
-                        tr("Error"),
-                        JOptionPane.ERROR_MESSAGE
-                );
-            }
-        }
-
+        // notify user about removed deprecated plugins
+        //
+        StringBuffer sb = new StringBuffer();
+        sb.append("<html>");
+        sb.append(trn(
+                "The following plugin is no longer necessary and has been deactivated:",
+                "The following plugins are no longer necessary and have been deactivated:",
+                removedPlugins.size()
+        ));
+        sb.append("<ul>");
+        for (String name: removedPlugins) {
+            sb.append("<li>").append(name).append("</li>");
+        }
+        sb.append("</ul>");
+        sb.append("</html>");
+        JOptionPane.showMessageDialog(
+                Main.parent,
+                sb.toString(),
+                tr("Warning"),
+                JOptionPane.WARNING_MESSAGE
+        );
+    }
+
+    /**
+     * Removes unmaintained plugins from a collection of plugins. Modifies the
+     * collection <code>plugins</code>. Also removes the plugin from the list
+     * of plugins in the preferences, if necessary.
+     * 
+     * Asks the user for every unmaintained plugin whether it should be removed.
+     * 
+     * @param plugins the collection of plugins
+     */
+    private static void filterUnmaintainedPlugins(Collection<String> plugins) {
+        for (String unmaintained : UNMAINTAINED_PLUGINS) {
+            if (!plugins.contains(unmaintained)) {
+                continue;
+            }
+            String msg =  tr("<html>Loading of {0} plugin was requested."
+                    + "<br>This plugin is no longer developed and very likely will produce errors."
+                    +"<br>It should be disabled.<br>Delete from preferences?</html>", unmaintained);
+            if (confirmDisablePlugin(msg,unmaintained)) {
+                Main.pref.removeFromCollection("plugins", unmaintained);
+                plugins.remove(unmaintained);
+            }
+        }
+    }
+
+    /**
+     * Checks whether the locally available plugins should be updated and
+     * asks the user if running an update is OK. An update is advised if
+     * JOSM was updated to a new version since the last plugin updates or
+     * if the plugins were last updated a long time ago.
+     * 
+     * @return true if a plugin update should be run; false, otherwise
+     */
+    public static boolean checkAndConfirmPluginUpdate() {
+        String message = null;
+        String togglePreferenceKey = null;
+        int v = Version.getInstance().getVersion();
+        if (Main.pref.getInteger("pluginmanager.version", 0) < v) {
+            message = tr("<html>You updated your JOSM software.<br>"
+                    + "To prevent problems the plugins should be updated as well.<br><br>"
+                    + "Update plugins now?"
+                    + "</html>"
+            );
+            togglePreferenceKey = "pluginmanger.version";
+        }  else {
+            long tim = System.currentTimeMillis();
+            long last = Main.pref.getLong("pluginmanager.lastupdate", 0);
+            Integer maxTime = Main.pref.getInteger("pluginmanager.warntime", 60);
+            long d = (tim - last) / (24 * 60 * 60 * 1000l);
+            if ((last <= 0) || (maxTime <= 0)) {
+                Main.pref.put("pluginmanager.lastupdate", Long.toString(tim));
+            } else if (d > maxTime) {
+                message = tr("Last plugin update more than {0} days ago.", d);
+                togglePreferenceKey = "pluginmanager.time";
+            }
+        }
+        if (message == null) return false;
+
+        // ask whether update is fine
+        //
+        ExtendedDialog dialog = new ExtendedDialog(
+                Main.parent,
+                tr("Update plugins"),
+                new String[] {
+                    tr("Update plugins"), tr("Skip update")
+                }
+        );
+        dialog.setContent(message);
+        dialog.toggleEnable(togglePreferenceKey);
+        dialog.setButtonIcons( new String[] {"dialogs/refresh.png", "cancel.png"});
+        dialog.configureContextsensitiveHelp(ht("/Plugin/AutomaticUpdate"), true /* show help button */);
+        dialog.showDialog();
+        return dialog.getValue() == 1;
+    }
+
+    /**
+     * Alerts the user if a plugin required by another plugin is missing
+     * 
+     * @param plugin the the plugin
+     * @param missingRequiredPlugin the missing required plugin
+     */
+    private static void alertMissingRequiredPlugin(String plugin, Set<String> missingRequiredPlugin) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("<html>");
+        sb.append(trn("A required plugin for plugin {0} was not found. The required plugin is:",
+                "{1} required plugins for plugin {0} were not found. The required plugins are:",
+                missingRequiredPlugin.size(),
+                plugin,
+                missingRequiredPlugin.size()
+        ));
+        sb.append("<ul>");
+        for (String p: missingRequiredPlugin) {
+            sb.append("<li>").append(p).append("</li>");
+        }
+        sb.append("</ul>").append("</html>");
+        JOptionPane.showMessageDialog(
+                Main.parent,
+                sb.toString(),
+                tr("Error"),
+                JOptionPane.ERROR_MESSAGE
+        );
+    }
+
+    /**
+     * Checks whether all preconditions for loading the plugin <code>plugin</code> are met. The
+     * current JOSM version must be compatible with the plugin and no other plugins this plugin
+     * depends on should be missing.
+     * 
+     * @param plugins the collection of all loaded plugins
+     * @param plugin the plugin for which preconditions are checked
+     * @return true, if the preconditions are met; false otherwise
+     */
+    public static boolean checkLoadPreconditions(Collection<PluginInformation> plugins, PluginInformation plugin) {
+
+        // make sure the plugin is compatible with the current JOSM version
+        //
+        int josmVersion = Version.getInstance().getVersion();
+        if (plugin.mainversion > josmVersion && josmVersion != Version.JOSM_UNKNOWN_VERSION) {
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr("Plugin {0} requires JOSM update to version {1}.", plugin.name,
+                            plugin.mainversion),
+                            tr("Warning"),
+                            JOptionPane.WARNING_MESSAGE
+            );
+            return false;
+        }
+
+        // make sure the dependencies to other plugins are not broken
+        //
+        if(plugin.requires != null){
+            Set<String> pluginNames = new HashSet<String>();
+            for (PluginInformation pi: plugins) {
+                pluginNames.add(pi.name);
+            }
+            Set<String> missingPlugins = new HashSet<String>();
+            for (String requiredPlugin : plugin.requires.split(";")) {
+                if (!pluginNames.contains(requiredPlugin)) {
+                    missingPlugins.add(requiredPlugin);
+                }
+            }
+            if (!missingPlugins.isEmpty()) {
+                alertMissingRequiredPlugin(plugin.name, missingPlugins);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Creates a class loader for loading plugin code.
+     * 
+     * @param plugins the collection of plugins which are going to be loaded with this
+     * class loader
+     * @return the class loader
+     */
+    public static ClassLoader createClassLoader(Collection<PluginInformation> plugins) {
         // iterate all plugins and collect all libraries of all plugins:
-        List<URL> allPluginLibraries = new ArrayList<URL>();
-        for (Collection<PluginInformation> c : p.values()) {
-            for (PluginInformation info : c) {
-                allPluginLibraries.addAll(info.libraries);
-            }
-        }
+        List<URL> allPluginLibraries = new LinkedList<URL>();
+        File pluginDir = Main.pref.getPluginsDirectory();
+        for (PluginInformation info : plugins) {
+            if (info.libraries == null) {
+                continue;
+            }
+            allPluginLibraries.addAll(info.libraries);
+            File pluginJar = new File(pluginDir, info.name + ".jar");
+            URL pluginJarUrl = PluginInformation.fileToURL(pluginJar);
+            allPluginLibraries.add(pluginJarUrl);
+        }
+
         // create a classloader for all plugins:
         URL[] jarUrls = new URL[allPluginLibraries.size()];
         jarUrls = allPluginLibraries.toArray(jarUrls);
         URLClassLoader pluginClassLoader = new URLClassLoader(jarUrls, Main.class.getClassLoader());
-        ImageProvider.sources.add(0, pluginClassLoader);
-
-        for (Collection<PluginInformation> c : p.values()) {
-            for (PluginInformation info : c) {
-                try {
-                    Class<?> klass = info.loadClass(pluginClassLoader);
-                    if (klass != null) {
-                        System.out.println("loading "+info.name);
-                        pluginList.add(info.load(klass));
+        return pluginClassLoader;
+    }
+
+    /**
+     * Loads and instantiates the plugin described by <code>plugin</code> using
+     * the class loader <code>pluginClassLoader</code>.
+     * 
+     * @param plugin the plugin
+     * @param pluginClassLoader the plugin class loader
+     */
+    public static void loadPlugin(PluginInformation plugin, ClassLoader pluginClassLoader) {
+        try {
+            Class<?> klass = plugin.loadClass(pluginClassLoader);
+            if (klass != null) {
+                System.out.println(tr("loading plugin ''{0}''", plugin.name));
+                pluginList.add(plugin.load(klass));
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+            String msg = tr("Could not load plugin {0}. Delete from preferences?", plugin.name);
+            if (confirmDisablePlugin(msg, plugin.name)) {
+                Main.pref.removeFromCollection("plugins", plugin.name);
+            }
+        }
+    }
+
+    /**
+     * Loads the plugin in <code>plugins</code> from locally available jar files into
+     * memory.
+     * 
+     * @param plugins the list of plugins
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     */
+    public static void loadPlugins(Collection<PluginInformation> plugins, ProgressMonitor monitor) {
+        if (monitor == null) {
+            monitor = NullProgressMonitor.INSTANCE;
+        }
+        try {
+            monitor.beginTask(tr("Loading plugins ..."));
+            List<PluginInformation> toLoad = new LinkedList<PluginInformation>();
+            // sort the plugins according to their "staging" equivalence class. The
+            // lower the value of "stage" the earlier the plugin should be loaded.
+            //
+            Collections.sort(
+                    toLoad,
+                    new Comparator<PluginInformation>() {
+                        public int compare(PluginInformation o1, PluginInformation o2) {
+                            if (o1.stage < o2.stage) return -1;
+                            if (o1.stage == o2.stage) return 0;
+                            return 1;
+                        }
                     }
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                    disablePlugin(tr("Could not load plugin {0}. Delete from preferences?", info.name), info.name);
-                }
-            }
-        }
-    }
-    public static boolean disablePlugin(String reason, String name)
-    {
+            );
+            monitor.subTask(tr("Checking plugin preconditions..."));
+            for (PluginInformation pi: plugins) {
+                if (checkLoadPreconditions(plugins, pi)) {
+                    toLoad.add(pi);
+                }
+            }
+            if (toLoad.isEmpty())
+                return;
+
+            ClassLoader pluginClassLoader = createClassLoader(toLoad);
+            ImageProvider.sources.add(0, pluginClassLoader);
+            monitor.setTicksCount(toLoad.size());
+            for (PluginInformation info : toLoad) {
+                monitor.setExtraText(tr("Loading plugin ''{0}''...", info.name));
+                loadPlugin(info, pluginClassLoader);
+                monitor.worked(1);
+            }
+        } finally {
+            monitor.finishTask();
+        }
+    }
+
+    /**
+     * Loads plugins from <code>plugins</code> which have the flag {@see PluginInformation#early}
+     * set to true.
+     * 
+     * @param plugins the collection of plugins
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     */
+    public static void loadEarlyPlugins(Collection<PluginInformation> plugins, ProgressMonitor monitor) {
+        List<PluginInformation> earlyPlugins = new ArrayList<PluginInformation>(plugins.size());
+        for (PluginInformation pi: plugins) {
+            if (pi.early) {
+                earlyPlugins.add(pi);
+            }
+        }
+        loadPlugins(earlyPlugins, monitor);
+    }
+
+    /**
+     * Loads plugins from <code>plugins</code> which have the flag {@see PluginInformation#early}
+     * set to false.
+     * 
+     * @param plugins the collection of plugins
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     */
+    public static void loadLatePlugins(Collection<PluginInformation> plugins, ProgressMonitor monitor) {
+        List<PluginInformation> latePlugins = new ArrayList<PluginInformation>(plugins.size());
+        for (PluginInformation pi: plugins) {
+            if (!pi.early) {
+                latePlugins.add(pi);
+            }
+        }
+        loadPlugins(latePlugins, monitor);
+    }
+
+    /**
+     * Loads locally available plugin information from local plugin jars and from cached
+     * plugin lists.
+     *
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     * @return the list of locally available plugin information
+     * 
+     */
+    private static Map<String, PluginInformation> loadLocallyAvailablePluginInformation(ProgressMonitor monitor) {
+        if (monitor == null) {
+            monitor = NullProgressMonitor.INSTANCE;
+        }
+        try {
+            ReadLocalPluginInformationTask task = new ReadLocalPluginInformationTask(monitor);
+            ExecutorService service = Executors.newSingleThreadExecutor();
+            Future<?> future = service.submit(task);
+            try {
+                future.get();
+            } catch(ExecutionException e) {
+                e.printStackTrace();
+                return null;
+            } catch(InterruptedException e) {
+                e.printStackTrace();
+                return null;
+            }
+            HashMap<String, PluginInformation> ret = new HashMap<String, PluginInformation>();
+            for (PluginInformation pi: task.getAvailablePlugins()) {
+                ret.put(pi.name, pi);
+            }
+            return ret;
+        } finally {
+            monitor.finishTask();
+        }
+    }
+
+    private static void alertMissingPluginInformation(Collection<String> plugins) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("<html>");
+        sb.append(trn("JOSM could not find information about the following plugin:",
+                "JOSM could not find information about the following plugins:",
+                plugins.size()));
+        sb.append("<ul>");
+        for (String plugin: plugins) {
+            sb.append("<li>").append(plugin).append("</li>");
+        }
+        sb.append("</ul>");
+        sb.append(trn("The plugin is not going to be loaded.",
+                "The plugins are not going to be loaded.",
+                plugins.size()));
+        sb.append("</html>");
+        JOptionPane.showMessageDialog(
+                Main.parent,
+                sb.toString(),
+                tr("Warning"),
+                JOptionPane.WARNING_MESSAGE
+        );
+    }
+
+    /**
+     * Builds the set of plugins to load. Deprecated and unmaintained plugins are filtered
+     * out. This involves user interaction. This method displays alert and confirmation
+     * messages.
+     *
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     * @return the set of plugins to load (as set of plugin names)
+     */
+    public static List<PluginInformation> buildListOfPluginsToLoad(ProgressMonitor monitor) {
+        if (monitor == null) {
+            monitor = NullProgressMonitor.INSTANCE;
+        }
+        try {
+            monitor.beginTask(tr("Determine plugins to load..."));
+            Set<String> plugins = new HashSet<String>();
+            plugins.addAll(Main.pref.getCollection("plugins",  new LinkedList<String>()));
+            if (System.getProperty("josm.plugins") != null) {
+                plugins.addAll(Arrays.asList(System.getProperty("josm.plugins").split(",")));
+            }
+            monitor.subTask(tr("Removing deprecated plugins..."));
+            filterDeprecatedPlugins(plugins);
+            monitor.subTask(tr("Removing umaintained plugins..."));
+            filterUnmaintainedPlugins(plugins);
+            Map<String, PluginInformation> infos = loadLocallyAvailablePluginInformation(monitor.createSubTaskMonitor(1,false));
+            List<PluginInformation> ret = new LinkedList<PluginInformation>();
+            for (Iterator<String> it = plugins.iterator(); it.hasNext();) {
+                String plugin = it.next();
+                if (infos.containsKey(plugin)) {
+                    ret.add(infos.get(plugin));
+                    it.remove();
+                }
+            }
+            if (!plugins.isEmpty()) {
+                alertMissingPluginInformation(plugins);
+            }
+            return ret;
+        } finally {
+            monitor.finishTask();
+        }
+    }
+
+    private static void alertFailedPluginUpdate(Collection<PluginInformation> plugins) {
+        StringBuffer sb = new StringBuffer();
+        sb.append("<html>");
+        sb.append(trn(
+                "Updating the following plugin has failed:",
+                "Updating the following plugins has failed:",
+                plugins.size()
+        )
+        );
+        sb.append("<ul>");
+        for (PluginInformation pi: plugins) {
+            sb.append("<li>").append(pi.name).append("</li>");
+        }
+        sb.append("</ul>");
+        sb.append(tr("Please open the Preference Dialog after JOSM has started and try to update them manually."));
+        sb.append("</html>");
+        JOptionPane.showMessageDialog(
+                Main.parent,
+                sb.toString(),
+                tr("Plugin update failed"),
+                JOptionPane.ERROR_MESSAGE
+        );
+    }
+
+    /**
+     * Updates the plugins in <code>plugins</code>.
+     * 
+     * @param plugins the collection of plugins to update. Must not be null.
+     * @param monitor the progress monitor. Defaults to {@see NullProgressMonitor#INSTANCE} if null.
+     * @throws IllegalArgumentException thrown if plugins is null
+     */
+    public static void updatePlugins(Collection<PluginInformation> plugins, ProgressMonitor monitor) throws IllegalArgumentException{
+        CheckParameterUtil.ensureParameterNotNull(plugins, "plugins");
+        if (monitor == null) {
+            monitor = NullProgressMonitor.INSTANCE;
+        }
+        try {
+            PluginDownloadTask task = new PluginDownloadTask(
+                    monitor,
+                    plugins,
+                    tr("Update plugins")
+            );
+            ExecutorService service = Executors.newSingleThreadExecutor();
+            Future<?> future = service.submit(task);
+            try {
+                future.get();
+            } catch(ExecutionException e) {
+                e.printStackTrace();
+            } catch(InterruptedException e) {
+                e.printStackTrace();
+            }
+            if (! task.getFailedPlugins().isEmpty()) {
+                alertFailedPluginUpdate(task.getFailedPlugins());
+                return;
+            }
+        } finally {
+            monitor.finishTask();
+        }
+        // remember the update because it was successful
+        //
+        Main.pref.putInteger("pluginmanager.version", Version.getInstance().getVersion());
+        Main.pref.put("pluginmanager.lastupdate", Long.toString(System.currentTimeMillis()));
+    }
+
+    /**
+     * Ask the user for confirmation that a plugin shall be disabled.
+     * 
+     * @param reason the reason for disabling the plugin
+     * @param name the plugin name
+     * @return true, if the plugin shall be disabled; false, otherwise
+     */
+    public static boolean confirmDisablePlugin(String reason, String name) {
         ExtendedDialog dialog = new ExtendedDialog(
                 Main.parent,
                 tr("Disable plugin"),
-                new String[] {tr("Disable plugin"), tr("Keep plugin")}
+                new String[] {
+                    tr("Disable plugin"), tr("Keep plugin")
+                }
         );
         dialog.setContent(reason);
-        dialog.setButtonIcons( new String[] {"dialogs/delete.png", "cancel.png"});
+        dialog.setButtonIcons(new String[] { "dialogs/delete.png", "cancel.png" });
         dialog.showDialog();
-        int result = dialog.getValue();
-
-        if(result == 1)
-        {
-            Main.pref.removeFromCollection("plugins", name);
-            return true;
-        }
-        return false;
-    }
-
-    public static void setMapFrame(MapFrame old, MapFrame map) {
+        return dialog.getValue() == 1;
+    }
+
+    /**
+     * Notified loaded plugins about a new map frame
+     * 
+     * @param old the old map frame
+     * @param map the new map frame
+     */
+    public static void notifyMapFrameChanged(MapFrame old, MapFrame map) {
         for (PluginProxy plugin : pluginList) {
             plugin.mapFrameInitialized(old, map);
@@ -248 +603 @@
     }
 
-    public static void addDownloadSelection(List<DownloadSelection> downloadSelections)
-    {
+    public static void addDownloadSelection(List<DownloadSelection> downloadSelections) {
         for (PluginProxy p : pluginList) {
             p.addDownloadSelection(downloadSelections);
         }
     }
-    public static void getPreferenceSetting(Collection<PreferenceSettingFactory> settings)
-    {
+
+    public static void getPreferenceSetting(Collection<PreferenceSettingFactory> settings) {
         for (PluginProxy plugin : pluginList) {
             settings.add(new PluginPreferenceFactory(plugin));
@@ -261 +615 @@
     }
 
-    public static void earlyCleanup()
-    {
-        if (!PluginDownloader.moveUpdatedPlugins()) {
-            JOptionPane.showMessageDialog(
-                    Main.parent,
-                    tr("Activating the updated plugins failed. Check if JOSM has the permission to overwrite the existing ones."),
-                    tr("Plugins"), JOptionPane.ERROR_MESSAGE);
-        }
-    }
-    public static Boolean checkException(Throwable e)
+    /**
+     * Installs downloaded plugins. Moves files with the suffix ".jar.new" to the corresponding
+     * ".jar" files.
+     * 
+     */
+    public static void installDownloadedPlugins() {
+        File pluginDir = Main.pref.getPluginsDirectory();
+        if (! pluginDir.exists() || ! pluginDir.isDirectory() || ! pluginDir.canWrite())
+            return;
+
+        final File[] files = pluginDir.listFiles(new FilenameFilter() {
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".jar.new");
+            }});
+
+        for (File updatedPlugin : files) {
+            final String filePath = updatedPlugin.getPath();
+            File plugin = new File(filePath.substring(0, filePath.length() - 4));
+            String pluginName = updatedPlugin.getName().substring(0, updatedPlugin.getName().length() - 8);
+            if (plugin.exists()) {
+                if (!plugin.delete()) {
+                    System.err.println(tr("Warning: failed to delete outdated plugin ''{0}''.", plugin.toString()));
+                    System.err.println(tr("Warning: failed to install already downloaded plugin ''{0}''. Skipping installation. JOSM still going to load the old plugin version.", pluginName));
+                    continue;
+                }
+            }
+            if (!updatedPlugin.renameTo(plugin)) {
+                System.err.println(tr("Warning: failed to install plugin ''{0}'' from temporary download file ''{1}''. Renaming failed.", plugin.toString(), updatedPlugin.toString()));
+                System.err.println(tr("Warning: failed to install already downloaded plugin ''{0}''. Skipping installation. JOSM still going to load the old plugin version.", pluginName));
+            }
+        }
+        return;
+    }
+
+    public static boolean checkException(Throwable e)
     {
         PluginProxy plugin = null;
@@ -350 +729 @@
         return false;
     }
-    public static String getBugReportText()
-    {
+
+    public static String getBugReportText() {
         String text = "";
         String pl = Main.pref.getCollectionAsString("plugins");
-        if(pl != null && pl.length() != 0) {
-            text += "Plugins: "+pl+"\n";
+        if (pl != null && pl.length() != 0) {
+            text += "Plugins: " + pl + "\n";
         }
         for (final PluginProxy pp : pluginList) {
-            text += "Plugin " + pp.info.name + (pp.info.version != null && !pp.info.version.equals("") ? " Version: "+pp.info.version+"\n" : "\n");
+            text += "Plugin "
+                + pp.info.name
+                + (pp.info.version != null && !pp.info.version.equals("") ? " Version: " + pp.info.version + "\n"
+                        : "\n");
         }
         return text;
     }
-    public static JPanel getInfoPanel()
-    {
+
+    public static JPanel getInfoPanel() {
         JPanel pluginTab = new JPanel(new GridBagLayout());
         for (final PluginProxy p : pluginList) {
-            String name = p.info.name + (p.info.version != null && !p.info.version.equals("") ? " Version: "+p.info.version : "");
+            String name = p.info.name
+            + (p.info.version != null && !p.info.version.equals("") ? " Version: " + p.info.version : "");
             pluginTab.add(new JLabel(name), GBC.std());
             pluginTab.add(Box.createHorizontalGlue(), GBC.std().fill(GBC.HORIZONTAL));
-            pluginTab.add(new JButton(new AbstractAction(tr("Information")){
+            pluginTab.add(new JButton(new AbstractAction(tr("Information")) {
                 public void actionPerformed(ActionEvent event) {
                     StringBuilder b = new StringBuilder();
-                    for (Entry<String,String> e : p.info.attr.entrySet()) {
+                    for (Entry<String, String> e : p.info.attr.entrySet()) {
                         b.append(e.getKey());
                         b.append(": ");
@@ -378 +761 @@
                         b.append("\n");
                     }
-                    JTextArea a = new JTextArea(10,40);
+                    JTextArea a = new JTextArea(10, 40);
                     a.setEditable(false);
                     a.setText(b.toString());
-                    JOptionPane.showMessageDialog(
-                            Main.parent,
-                            new JScrollPane(a),
-                            tr("Plugin information"),
-                            JOptionPane.INFORMATION_MESSAGE
-                    );
+                    JOptionPane.showMessageDialog(Main.parent, new JScrollPane(a), tr("Plugin information"),
+                            JOptionPane.INFORMATION_MESSAGE);
                 }
             }), GBC.eol());
 
-            JTextArea description = new JTextArea((p.info.description==null? tr("no description available"):p.info.description));
+            JTextArea description = new JTextArea((p.info.description == null ? tr("no description available")
+                    : p.info.description));
             description.setEditable(false);
             description.setFont(new JLabel().getFont().deriveFont(Font.ITALIC));
             description.setLineWrap(true);
             description.setWrapStyleWord(true);
-            description.setBorder(BorderFactory.createEmptyBorder(0,20,0,0));
+            description.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
             description.setBackground(UIManager.getColor("Panel.background"));
 

trunk/src/org/openstreetmap/josm/plugins/PluginInformation.java

@@ -43 +43 @@
     public int stage = 50;
     public String version = null;
+    public String localversion = null;
     public String downloadlink = null;
     public List<URL> libraries = new LinkedList<URL>();
@@ -60 +61 @@
      * @param file the plugin jar file.
      */
-    public PluginInformation(File file) {
+    public PluginInformation(File file) throws PluginException{
         this(file, file.getName().substring(0, file.getName().length()-4));
     }
 
-    public PluginInformation(File file, String name) {
+    public PluginInformation(File file, String name) throws PluginException{
         this.name = name;
         this.file = file;
+        JarInputStream jar = null;
         try {
-            JarInputStream jar = new JarInputStream(new FileInputStream(file));
+            jar = new JarInputStream(new FileInputStream(file));
             Manifest manifest = jar.getManifest();
             if (manifest == null)
-                throw new IOException(file+" contains no manifest.");
+                throw new PluginException(name, tr("The plugin file ''{0}'' doesn't include a Manifest.", file.toString()));
             scanManifest(manifest, false);
             libraries.add(0, fileToURL(file));
-            jar.close();
         } catch (IOException e) {
-            throw new PluginException(null, name, e);
-        }
-    }
-
-    public PluginInformation(InputStream manifestStream, String name, String url) {
+            throw new PluginException(name, e);
+        } finally {
+            if (jar != null) {
+                try {
+                    jar.close();
+                } catch(IOException e) { /* ignore */ }
+            }
+        }
+    }
+
+    public PluginInformation(InputStream manifestStream, String name, String url) throws PluginException {
         this.name = name;
         try {
@@ -90 +97 @@
             scanManifest(manifest, url != null);
         } catch (IOException e) {
-            throw new PluginException(null, name, e);
+            throw new PluginException(name, e);
         }
     }
@@ -167 +174 @@
     }
 
-    public String getLinkDescription()
-    {
-        String d = description == null ? tr("no description available") : description;
-        if(link != null) {
-            d += " <A HREF=\""+link+"\">"+tr("More details")+"</A>";
-        }
-        return d;
+    /**
+     * Replies the description as HTML document, including a link to a web page with
+     * more information, provided such a link is available.
+     * 
+     * @return the description as HTML document
+     */
+    public String getDescriptionAsHtml() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("<html><body>");
+        sb.append(description == null ? tr("no description available") : description);
+        if (link != null) {
+            sb.append(" <a href=\"").append(link).append("\">").append(tr("More info...")).append("</a>");
+        }
+        sb.append("</body></html>");
+        return sb.toString();
     }
 
@@ -179 +194 @@
      * Load and instantiate the plugin
      */
-    public PluginProxy load(Class<?> klass) {
+    public PluginProxy load(Class<?> klass) throws PluginException{
         try {
             currentPluginInitialization = this;
             return new PluginProxy(klass.newInstance(), this);
-        } catch (Exception e) {
-            throw new PluginException(null, name, e);
+        } catch(IllegalAccessException e) {
+            throw new PluginException(name, e);
+        } catch (InstantiationException e) {
+            throw new PluginException(name, e);
         }
     }
@@ -191 +208 @@
      * Load the class of the plugin
      */
-    public Class<?> loadClass(ClassLoader classLoader) {
+    public Class<?> loadClass(ClassLoader classLoader) throws PluginException {
         if (className == null)
             return null;
-        try {
+        try{
             Class<?> realClass = Class.forName(className, true, classLoader);
             return realClass;
-        } catch (Exception e) {
-            throw new PluginException(null, name, e);
+        } catch (ClassNotFoundException e) {
+            throw new PluginException(name, e);
         }
     }
@@ -272 +289 @@
         return all;
     }
+
+    /**
+     * Replies true if the plugin with the given information is most likely outdated with
+     * respect to the referenceVersion.
+     * 
+     * @param referenceVersion the reference version. Can be null if we don't know a
+     * reference version
+     * 
+     * @return true, if the plugin needs to be updated; false, otherweise
+     */
+    public boolean isUpdateRequired(String referenceVersion) {
+        if (this.version == null && referenceVersion!= null)
+            return true;
+        if (this.version != null && !this.version.equals(referenceVersion))
+            return true;
+        return false;
+    }
+
+    /**
+     * Replies true if this this plugin should be updated/downloaded because either
+     * it is not available locally (its local version is null) or its local version is
+     * older than the available version on the server.
+     * 
+     * @return true if the plugin should be updated
+     */
+    public boolean isUpdateRequired() {
+        if (this.localversion == null) return false;
+        return isUpdateRequired(this.localversion);
+    }
+
+    protected boolean matches(String filter, String value) {
+        if (filter == null) return true;
+        if (value == null) return false;
+        return value.toLowerCase().contains(filter.toLowerCase());
+    }
+
+    /**
+     * Replies true if either the name, the description, or the version match (case insensitive)
+     * one of the words in filter. Replies true if filter is null.
+     * 
+     * @param filter the filter expression
+     * @return true if this plugin info matches with the filter
+     */
+    public boolean matches(String filter) {
+        if (filter == null) return true;
+        String words[] = filter.split("\\s+");
+        for (String word: words) {
+            if (matches(word, name)
+                    || matches(word, description)
+                    || matches(word, version)
+                    || matches(word, localversion))
+                return true;
+        }
+        return false;
+    }
+
+    /**
+     * Replies the name of the plugin
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Sets the name
+     * @param name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
 }