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         final Long longId = Long.valueOf(id);
 130
 131         JPanel progressPanel = progressBars.get(longId);
 132         if (progressPanel != null)
 133         {
 134           /*
 135            * Progress bar is displayed for this id - remove it now, and any handler
 136            */
 137           progressBars.remove(id);
 138           if (message != null && statusBar != null)
 139           {
 140             statusBar.setText(message);
 141           }
 142           if (progressBarHandlers.containsKey(longId))
 143           {
 144             progressBarHandlers.remove(longId);
 145           }
 146           removeRow(progressPanel);
 147         }
 148         else
 149         {
 150           /*
 151            * No progress bar for this id - add one now
 152            */
 153           progressPanel = new JPanel(new BorderLayout(10, 5));
 154
 155           JProgressBar progressBar = new JProgressBar();
 156           progressBar.setIndeterminate(true);
 157
 158           progressPanel.add(new JLabel(message), BorderLayout.WEST);
 159           progressPanel.add(progressBar, BorderLayout.CENTER);
 160
 161           addRow(progressPanel);
 162
 163           progressBars.put(longId, progressPanel);
 164         }
 165
 166         refreshLayout();
 167       }
 168     });
 169
 170   }
 171
 172   /**
 173    * Lays out progress bar container hierarchy
 174    */
 175   protected void refreshLayout()
 176   {
 177     /*
 178      * lay out progress bar container hierarchy
 179      */
 180     Component root = SwingUtilities.getRoot(statusPanel);
 181     if (root != null)
 182     {
 183       root.validate();
 184     }
 185   }
 186
 187   /**
 188    * Remove one row with a progress bar, in a thread-safe manner
 189    *
 190    * @param progressPanel
 191    */
 192   protected void removeRow(JPanel progressPanel)
 193   {
 194     synchronized (statusPanel)
 195     {
 196       statusPanel.remove(progressPanel);
 197       GridLayout layout = (GridLayout) statusPanel.getLayout();
 198       layout.setRows(layout.getRows() - 1);
 199       statusPanel.remove(progressPanel);
 200     }
 201   }
 202
 203   /**
 204    * Add one row with a progress bar, in a thread-safe manner
 205    *
 206    * @param progressPanel
 207    */
 208   protected void addRow(JPanel progressPanel)
 209   {
 210     synchronized (statusPanel)
 211     {
 212       GridLayout layout = (GridLayout) statusPanel.getLayout();
 213       layout.setRows(layout.getRows() + 1);
 214       statusPanel.add(progressPanel);
 215     }
 216   }
 217
 218   /**
 219    * Add a 'Cancel' handler for the given progress bar id. This should be called
 220    * _after_ setProgressBar to have any effect.
 221    */
 222   @Override
 223   public void registerHandler(final long id,
 224           final IProgressIndicatorHandler handler)
 225   {
 226     final IProgressIndicator us = this;
 227
 228     SwingUtilities.invokeLater(new Runnable()
 229     {
 230       @Override
 231       public void run()
 232       {
 233         Long longId = Long.valueOf(id);
 234         final JPanel progressPanel = progressBars.get(longId);
 235         if (progressPanel == null)
 236         {
 237           System.err.println(
 238                   "call setProgressBar before registering the progress bar's handler.");
 239           return;
 240         }
 241
 242         /*
 243          * Nothing useful to do if not a Cancel handler
 244          */
 245         if (!handler.canCancel())
 246         {
 247           return;
 248         }
 249
 250         progressBarHandlers.put(longId, handler);
 251         JButton cancel = new JButton(
 252                 MessageManager.getString("action.cancel"));
 253         cancel.addActionListener(new ActionListener()
 254         {
 255
 256           @Override
 257           public void actionPerformed(ActionEvent e)
 258           {
 259             handler.cancelActivity(id);
 260             us.setProgressBar(MessageManager
 261                     .formatMessage("label.cancelled_params", new Object[]
 262                     { ((JLabel) progressPanel.getComponent(0)).getText() }),
 263                     id);
 264           }
 265         });
 266         progressPanel.add(cancel, BorderLayout.EAST);
 267         refreshLayout();
 268
 269       }
 270     });
 271   }
 272
 273 }