src/jalview/gui/ProgressBar.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.util.MessageManager;
  24
  25 import java.awt.BorderLayout;
  26 import java.awt.Component;
  27 import java.awt.GridLayout;
  28 import java.awt.event.ActionEvent;
  29 import java.awt.event.ActionListener;
  30 import java.util.Hashtable;
  31 import java.util.Map;
  32
  33 import javax.swing.JButton;
  34 import javax.swing.JLabel;
  35 import javax.swing.JPanel;
  36 import javax.swing.JProgressBar;
  37 import javax.swing.SwingUtilities;
  38
  39 /**
  40  * A class to manage multiple progress bars embedded in a JPanel.
  41  */
  42 /*
  43  * Refactored from code duplicated in AlignFrame, PCAPanel, WebserviceInfo.
  44  */
  45 public class ProgressBar implements IProgressIndicator
  46 {
  47   /*
  48    * Progress bars in progress, keyed by any arbitrary long value
  49    */
  50   Map<Long, JPanel> progressBars;
  51
  52   /*
  53    * Optional handlers for the progress bars
  54    */
  55   Map<Long, IProgressIndicatorHandler> progressBarHandlers;
  56
  57   /*
  58    * The panel containing the progress bars - must have GridLayout
  59    */
  60   private JPanel statusPanel;
  61
  62   /*
  63    * Optional label where a status update message can be written on completion
  64    * of progress
  65    */
  66   private JLabel statusBar;
  67
  68   /**
  69    * Constructor. Note that the container of the progress bars, and the status
  70    * bar to which an optional completion message is written, should be unchanged
  71    * for the lifetime of this object for consistent behaviour.
  72    *
  73    * @param container
  74    *          the panel holding the progress bars; must have GridLayout manager
  75    * @param statusBar
  76    *          an optional place to write a message when a progress bar is
  77    *          removed
  78    */
  79   public ProgressBar(JPanel container, JLabel statusBar)
  80   {
  81     if (container == null)
  82     {
  83       throw new NullPointerException();
  84     }
  85     if (!GridLayout.class
  86             .isAssignableFrom(container.getLayout().getClass()))
  87     {
  88       throw new IllegalArgumentException("Container must have GridLayout");
  89     }
  90     this.statusPanel = container;
  91     this.statusBar = statusBar;
  92     this.progressBars = new Hashtable<>();
  93     this.progressBarHandlers = new Hashtable<>();
  94
  95   }
  96
  97   /**
  98    * Returns true if any progress bars are still active
  99    *
 100    * @return
 101    */
 102   @Override
 103   public boolean operationInProgress()
 104   {
 105     if (progressBars != null && progressBars.size() > 0)
 106     {
 107       return true;
 108     }
 109     return false;
 110   }
 111
 112   /**
 113    * First call for a given id will show the message as a new progress bar. A
 114    * second call with the same id will remove it. The 'removal' message is
 115    * written to the status bar field (if neither is null).
 116    *
 117    * To avoid progress bars being left orphaned, ensure their removal is
 118    * performed in a finally block if there is any risk of an error during
 119    * execution.
 120    */
 121   @Override
 122   public void setProgressBar(final String message, final long id)
 123   {
 124     SwingUtilities.invokeLater(new Runnable()
 125     {
 126       @Override
 127       public void run()
 128       {
 129         JPanel progressPanel = progressBars.get(id);
 130         if (progressPanel != null)
 131         {
 132           /*
 133            * Progress bar is displayed for this id - remove it now, and any handler
 134            */
 135           progressBars.remove(id);
 136           if (message != null && statusBar != null)
 137           {
 138             statusBar.setText(message);
 139           }
 140           if (progressBarHandlers.containsKey(id))
 141           {
 142             progressBarHandlers.remove(id);
 143           }
 144           removeRow(progressPanel);
 145         }
 146         else
 147         {
 148           /*
 149            * No progress bar for this id - add one now
 150            */
 151           progressPanel = new JPanel(new BorderLayout(10, 5));
 152
 153           JProgressBar progressBar = new JProgressBar();
 154           progressBar.setIndeterminate(true);
 155
 156           progressPanel.add(new JLabel(message), BorderLayout.WEST);
 157           progressPanel.add(progressBar, BorderLayout.CENTER);
 158
 159           addRow(progressPanel);
 160
 161           progressBars.put(id, progressPanel);
 162         }
 163
 164         refreshLayout();
 165       }
 166     });
 167
 168   }
 169
 170   @Override
 171   public void removeProgressBar(final long id)
 172   {
 173     SwingUtilities.invokeLater(() -> {
 174       JPanel progressPanel = progressBars.get(id);
 175       if (progressPanel != null)
 176       {
 177         progressBars.remove(id);
 178         if (progressBarHandlers.containsKey(id))
 179         {
 180           progressBarHandlers.remove(id);
 181         }
 182         removeRow(progressPanel);
 183       }
 184     });
 185   }
 186
 187   /**
 188    * Lays out progress bar container hierarchy
 189    */
 190   protected void refreshLayout()
 191   {
 192     /*
 193      * lay out progress bar container hierarchy
 194      */
 195     Component root = SwingUtilities.getRoot(statusPanel);
 196     if (root != null)
 197     {
 198       root.validate();
 199     }
 200   }
 201
 202   /**
 203    * Remove one row with a progress bar, in a thread-safe manner
 204    *
 205    * @param progressPanel
 206    */
 207   protected void removeRow(JPanel progressPanel)
 208   {
 209     synchronized (statusPanel)
 210     {
 211       statusPanel.remove(progressPanel);
 212       GridLayout layout = (GridLayout) statusPanel.getLayout();
 213       layout.setRows(layout.getRows() - 1);
 214       statusPanel.remove(progressPanel);
 215     }
 216   }
 217
 218   /**
 219    * Add one row with a progress bar, in a thread-safe manner
 220    *
 221    * @param progressPanel
 222    */
 223   protected void addRow(JPanel progressPanel)
 224   {
 225     synchronized (statusPanel)
 226     {
 227       GridLayout layout = (GridLayout) statusPanel.getLayout();
 228       layout.setRows(layout.getRows() + 1);
 229       statusPanel.add(progressPanel);
 230     }
 231   }
 232
 233   /**
 234    * Add a 'Cancel' handler for the given progress bar id. This should be called
 235    * _after_ setProgressBar to have any effect.
 236    */
 237   @Override
 238   public void registerHandler(final long id,
 239           final IProgressIndicatorHandler handler)
 240   {
 241     final IProgressIndicator us = this;
 242
 243     SwingUtilities.invokeLater(new Runnable()
 244     {
 245       @Override
 246       public void run()
 247       {
 248         final JPanel progressPanel = progressBars.get(id);
 249         if (progressPanel == null)
 250         {
 251           System.err.println(
 252                   "call setProgressBar before registering the progress bar's handler.");
 253           return;
 254         }
 255
 256         /*
 257          * Nothing useful to do if not a Cancel handler
 258          */
 259         if (!handler.canCancel())
 260         {
 261           return;
 262         }
 263
 264         progressBarHandlers.put(id, handler);
 265         JButton cancel = new JButton(
 266                 MessageManager.getString("action.cancel"));
 267         cancel.addActionListener(new ActionListener()
 268         {
 269
 270           @Override
 271           public void actionPerformed(ActionEvent e)
 272           {
 273             handler.cancelActivity(id);
 274             us.setProgressBar(MessageManager
 275                     .formatMessage("label.cancelled_params", new Object[]
 276                     { ((JLabel) progressPanel.getComponent(0)).getText() }),
 277                     id);
 278           }
 279         });
 280         progressPanel.add(cancel, BorderLayout.EAST);
 281         refreshLayout();
 282
 283       }
 284     });
 285   }
 286
 287 }