src/jalview/gui/WebserviceInfo.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 java.awt.BorderLayout;
  24 import java.awt.Color;
  25 import java.awt.Dimension;
  26 import java.awt.Graphics;
  27 import java.awt.Graphics2D;
  28 import java.awt.GridLayout;
  29 import java.awt.Image;
  30 import java.awt.MediaTracker;
  31 import java.awt.RenderingHints;
  32 import java.awt.event.ActionEvent;
  33 import java.awt.image.BufferedImage;
  34 import java.util.Vector;
  35
  36 import javax.swing.JComponent;
  37 import javax.swing.JEditorPane;
  38 import javax.swing.JInternalFrame;
  39 import javax.swing.JPanel;
  40 import javax.swing.JScrollPane;
  41 import javax.swing.JTabbedPane;
  42 import javax.swing.JTextArea;
  43 import javax.swing.event.HyperlinkEvent;
  44 import javax.swing.event.HyperlinkListener;
  45 import javax.swing.event.InternalFrameAdapter;
  46 import javax.swing.event.InternalFrameEvent;
  47 import javax.swing.text.html.HTMLEditorKit;
  48 import javax.swing.text.html.StyleSheet;
  49
  50 import jalview.jbgui.GWebserviceInfo;
  51 import jalview.util.ChannelProperties;
  52 import jalview.util.MessageManager;
  53 import jalview.ws.WSClientI;
  54
  55 /**
  56  * Base class for web service client thread and gui TODO: create StAX parser to
  57  * extract html body content reliably when preparing html formatted job statuses
  58  *
  59  * @author $author$
  60  * @version $Revision$
  61  */
  62 public class WebserviceInfo extends GWebserviceInfo
  63         implements HyperlinkListener, IProgressIndicator
  64 {
  65
  66   /** Job is Queued */
  67   public static final int STATE_QUEUING = 0;
  68
  69   /** Job is Running */
  70   public static final int STATE_RUNNING = 1;
  71
  72   /** Job has finished with no errors */
  73   public static final int STATE_STOPPED_OK = 2;
  74
  75   /** Job has been cancelled with no errors */
  76   public static final int STATE_CANCELLED_OK = 3;
  77
  78   /** job has stopped because of some error */
  79   public static final int STATE_STOPPED_ERROR = 4;
  80
  81   /** job has failed because of some unavoidable service interruption */
  82   public static final int STATE_STOPPED_SERVERERROR = 5;
  83
  84   int currentStatus = STATE_QUEUING;
  85
  86   Image image;
  87
  88   float angle = 0f;
  89
  90   String title = "";
  91
  92   jalview.ws.WSClientI thisService;
  93
  94   boolean serviceIsCancellable;
  95
  96   JInternalFrame frame;
  97
  98   private IProgressIndicator progressBar;
  99
 100   @Override
 101   public void setVisible(boolean aFlag)
 102   {
 103     super.setVisible(aFlag);
 104     frame.setVisible(aFlag);
 105   }
 106
 107   JTabbedPane subjobs = null;
 108
 109   java.util.Vector jobPanes = null;
 110
 111   private boolean serviceCanMergeResults = false;
 112
 113   private boolean viewResultsImmediatly = true;
 114
 115   /**
 116    * Get
 117    *
 118    * @param flag
 119    *          to indicate if results will be shown in a new window as soon as
 120    *          they are available.
 121    */
 122   public boolean isViewResultsImmediatly()
 123   {
 124     return viewResultsImmediatly;
 125   }
 126
 127   /**
 128    * Set
 129    *
 130    * @param flag
 131    *          to indicate if results will be shown in a new window as soon as
 132    *          they are available.
 133    */
 134   public void setViewResultsImmediatly(boolean viewResultsImmediatly)
 135   {
 136     this.viewResultsImmediatly = viewResultsImmediatly;
 137   }
 138
 139   private StyleSheet getStyleSheet(HTMLEditorKit editorKit)
 140   {
 141
 142     // Copied blatantly from
 143     // http://www.velocityreviews.com/forums/t132265-string-into-htmldocument.html
 144     StyleSheet myStyleSheet = new StyleSheet();
 145
 146     myStyleSheet.addStyleSheet(editorKit.getStyleSheet());
 147
 148     editorKit.setStyleSheet(myStyleSheet);
 149
 150     /*
 151      * Set the style sheet rules here by reading them from the constants
 152      * interface.
 153      */
 154     /*
 155      * for (int ix=0; ix<CSS_RULES.length; ix++) {
 156      *
 157      * myStyleSheet.addRule(CSS_RULES[ix]);
 158      *
 159      * }
 160      */
 161     return myStyleSheet;
 162
 163   }
 164
 165   // tabbed or not
 166   public synchronized int addJobPane()
 167   {
 168     JScrollPane jobpane = new JScrollPane();
 169     JComponent _progressText;
 170     if (renderAsHtml)
 171     {
 172       JEditorPane progressText = new JEditorPane("text/html", "");
 173       progressText.addHyperlinkListener(this);
 174       _progressText = progressText;
 175       // progressText.setFont(new java.awt.Font("Verdana", 0, 10));
 176       // progressText.setBorder(null);
 177       progressText.setEditable(false);
 178       /*
 179        * HTMLEditorKit myEditorKit = new HTMLEditorKit();
 180        *
 181        * StyleSheet myStyleSheet = getStyleSheet(myEditorKit);
 182        *
 183        * HTMLDocument tipDocument = (HTMLDocument)
 184        * (myEditorKit.createDefaultDocument());
 185        *
 186        * progressText.setDocument(tipDocument);
 187        */progressText.setText("<html><h1>WS Job</h1></html>");
 188     }
 189     else
 190     {
 191       JTextArea progressText = new JTextArea();
 192       _progressText = progressText;
 193
 194       progressText.setFont(new java.awt.Font("Verdana", 0, 10));
 195       progressText.setBorder(null);
 196       progressText.setEditable(false);
 197       progressText.setText("WS Job");
 198       progressText.setLineWrap(true);
 199       progressText.setWrapStyleWord(true);
 200     }
 201     jobpane.setName("JobPane");
 202     jobpane.getViewport().add(_progressText, null);
 203     jobpane.setBorder(null);
 204     if (jobPanes == null)
 205     {
 206       jobPanes = new Vector();
 207     }
 208     int newpane = jobPanes.size();
 209     jobPanes.add(jobpane);
 210
 211     if (newpane == 0)
 212     {
 213       this.add(jobpane, BorderLayout.CENTER);
 214     }
 215     else
 216     {
 217       if (newpane == 1)
 218       {
 219         // revert to a tabbed pane.
 220         JScrollPane firstpane;
 221         this.remove(firstpane = (JScrollPane) jobPanes.get(0));
 222         subjobs = new JTabbedPane();
 223         this.add(subjobs, BorderLayout.CENTER);
 224         subjobs.add(firstpane);
 225         subjobs.setTitleAt(0, firstpane.getName());
 226       }
 227       subjobs.add(jobpane);
 228     }
 229     return newpane; // index for accessor methods below
 230   }
 231
 232   /**
 233    * Creates a new WebserviceInfo object.
 234    *
 235    * @param title
 236    *          short name and job type
 237    * @param info
 238    *          reference or other human readable description
 239    * @param makeVisible
 240    *          true to display the webservices window immediatly (otherwise need
 241    *          to call setVisible(true))
 242    */
 243   public WebserviceInfo(String title, String info, boolean makeVisible)
 244   {
 245     init(title, info, 520, 500, makeVisible);
 246   }
 247
 248   /**
 249    * Creates a new WebserviceInfo object.
 250    *
 251    * @param title
 252    *          DOCUMENT ME!
 253    * @param info
 254    *          DOCUMENT ME!
 255    * @param width
 256    *          DOCUMENT ME!
 257    * @param height
 258    *          DOCUMENT ME!
 259    */
 260   public WebserviceInfo(String title, String info, int width, int height,
 261           boolean makeVisible)
 262   {
 263     init(title, info, width, height, makeVisible);
 264   }
 265
 266   /**
 267    * DOCUMENT ME!
 268    *
 269    * @return DOCUMENT ME!
 270    */
 271   public jalview.ws.WSClientI getthisService()
 272   {
 273     return thisService;
 274   }
 275
 276   /**
 277    * Update state of GUI based on client capabilities (like whether the job is
 278    * cancellable, whether the 'merge results' button is shown.
 279    *
 280    * @param newservice
 281    *          service client to query for capabilities
 282    */
 283   public void setthisService(jalview.ws.WSClientI newservice)
 284   {
 285     thisService = newservice;
 286     serviceIsCancellable = newservice.isCancellable();
 287     frame.setClosable(!serviceIsCancellable);
 288     serviceCanMergeResults = newservice.canMergeResults();
 289     rebuildButtonPanel();
 290   }
 291
 292   private void rebuildButtonPanel()
 293   {
 294     if (buttonPanel != null)
 295     {
 296       buttonPanel.removeAll();
 297       if (serviceIsCancellable)
 298       {
 299         buttonPanel.add(cancel);
 300         frame.setClosable(false);
 301       }
 302       else
 303       {
 304         frame.setClosable(true);
 305       }
 306     }
 307   }
 308
 309   /**
 310    * DOCUMENT ME!
 311    *
 312    * @param title
 313    *          DOCUMENT ME!
 314    * @param info
 315    *          DOCUMENT ME!
 316    * @param width
 317    *          DOCUMENT ME!
 318    * @param height
 319    *          DOCUMENT ME!
 320    */
 321   void init(String title, String info, int width, int height,
 322           boolean makeVisible)
 323   {
 324     frame = new JInternalFrame();
 325     frame.setContentPane(this);
 326     Desktop.addInternalFrame(frame, title, makeVisible, width, height);
 327     frame.setClosable(false);
 328
 329     progressBar = new ProgressBar(statusPanel, statusBar);
 330
 331     this.title = title;
 332     setInfoText(info);
 333
 334     image = ChannelProperties.getImage("rotatable_logo.48");
 335
 336     MediaTracker mt = new MediaTracker(this);
 337     mt.addImage(image, 0);
 338
 339     try
 340     {
 341       mt.waitForID(0);
 342     } catch (Exception ex)
 343     {
 344     }
 345
 346     AnimatedPanel ap = new AnimatedPanel();
 347     ap.setPreferredSize(new Dimension(60, 60));
 348     titlePanel.add(ap, BorderLayout.WEST);
 349     titlePanel.add(titleText, BorderLayout.CENTER);
 350     setStatus(currentStatus);
 351
 352     Thread thread = new Thread(ap);
 353     thread.start();
 354     final WebserviceInfo thisinfo = this;
 355     frame.addInternalFrameListener(new InternalFrameAdapter()
 356     {
 357       @Override
 358       public void internalFrameClosed(InternalFrameEvent evt)
 359       {
 360         // System.out.println("Shutting down webservice client");
 361         WSClientI service = thisinfo.getthisService();
 362         if (service != null && service.isCancellable())
 363         {
 364           service.cancelJob();
 365         }
 366       }
 367     });
 368     frame.validate();
 369
 370   }
 371
 372   /**
 373    * DOCUMENT ME!
 374    *
 375    * @param status
 376    *          integer status from state constants
 377    */
 378   public void setStatus(int status)
 379   {
 380     currentStatus = status;
 381
 382     String message = null;
 383     switch (currentStatus)
 384     {
 385     case STATE_QUEUING:
 386       message = MessageManager.getString("label.state_queueing");
 387       break;
 388
 389     case STATE_RUNNING:
 390       message = MessageManager.getString("label.state_running");
 391       break;
 392
 393     case STATE_STOPPED_OK:
 394       message = MessageManager.getString("label.state_completed");
 395       break;
 396
 397     case STATE_CANCELLED_OK:
 398       message = MessageManager.getString("label.state_job_cancelled");
 399       break;
 400
 401     case STATE_STOPPED_ERROR:
 402       message = MessageManager.getString("label.state_job_error");
 403       break;
 404
 405     case STATE_STOPPED_SERVERERROR:
 406       message = MessageManager.getString("label.server_error_try_later");
 407       break;
 408     }
 409     titleText.setText(title + (message == null ? "" : " - " + message));
 410     titleText.repaint();
 411   }
 412
 413   /**
 414    * subjob status indicator
 415    *
 416    * @param jobpane
 417    * @param status
 418    */
 419   public void setStatus(int jobpane, int status)
 420   {
 421     if (jobpane < 0 || jobpane >= jobPanes.size())
 422     {
 423       throw new Error(MessageManager.formatMessage(
 424               "error.setstatus_called_non_existent_job_pane", new String[]
 425               { Integer.valueOf(jobpane).toString() }));
 426     }
 427     switch (status)
 428     {
 429     case STATE_QUEUING:
 430       setProgressName(jobpane + " - QUEUED", jobpane);
 431       break;
 432     case STATE_RUNNING:
 433       setProgressName(jobpane + " - RUNNING", jobpane);
 434       break;
 435     case STATE_STOPPED_OK:
 436       setProgressName(jobpane + " - FINISHED", jobpane);
 437       break;
 438     case STATE_CANCELLED_OK:
 439       setProgressName(jobpane + " - CANCELLED", jobpane);
 440       break;
 441     case STATE_STOPPED_ERROR:
 442       setProgressName(jobpane + " - BROKEN", jobpane);
 443       break;
 444     case STATE_STOPPED_SERVERERROR:
 445       setProgressName(jobpane + " - ALERT", jobpane);
 446       break;
 447     default:
 448       setProgressName(jobpane + " - UNKNOWN STATE", jobpane);
 449     }
 450   }
 451
 452   /**
 453    * DOCUMENT ME!
 454    *
 455    * @return DOCUMENT ME!
 456    */
 457   public String getInfoText()
 458   {
 459     return infoText.getText();
 460   }
 461
 462   /**
 463    * DOCUMENT ME!
 464    *
 465    * @param text
 466    *          DOCUMENT ME!
 467    */
 468   public void setInfoText(String text)
 469   {
 470     infoText.setText(text);
 471   }
 472
 473   /**
 474    * DOCUMENT ME!
 475    *
 476    * @param text
 477    *          DOCUMENT ME!
 478    */
 479   public void appendInfoText(String text)
 480   {
 481     infoText.append(text);
 482   }
 483
 484   /**
 485    * DOCUMENT ME!
 486    *
 487    * @return DOCUMENT ME!
 488    */
 489   public String getProgressText(int which)
 490   {
 491     if (jobPanes == null)
 492     {
 493       addJobPane();
 494     }
 495     if (renderAsHtml)
 496     {
 497       return ((JEditorPane) ((JScrollPane) jobPanes.get(which))
 498               .getViewport().getComponent(0)).getText();
 499     }
 500     else
 501     {
 502       return ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 503               .getComponent(0)).getText();
 504     }
 505   }
 506
 507   /**
 508    * DOCUMENT ME!
 509    *
 510    * @param text
 511    *          DOCUMENT ME!
 512    */
 513   public void setProgressText(int which, String text)
 514   {
 515     if (jobPanes == null)
 516     {
 517       addJobPane();
 518     }
 519     if (renderAsHtml)
 520     {
 521       ((JEditorPane) ((JScrollPane) jobPanes.get(which)).getViewport()
 522               .getComponent(0)).setText(ensureHtmlTagged(text));
 523     }
 524     else
 525     {
 526       ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 527               .getComponent(0)).setText(text);
 528     }
 529   }
 530
 531   /**
 532    * extract content from &lt;body&gt; content &lt;/body&gt;
 533    *
 534    * @param text
 535    * @param leaveFirst
 536    *          - set to leave the initial html tag intact
 537    * @param leaveLast
 538    *          - set to leave the final html tag intact
 539    * @return
 540    */
 541   private String getHtmlFragment(String text, boolean leaveFirst,
 542           boolean leaveLast)
 543   {
 544     if (text == null)
 545     {
 546       return null;
 547     }
 548     String lowertxt = text.toLowerCase();
 549     int htmlpos = leaveFirst ? -1 : lowertxt.indexOf("<body");
 550
 551     int htmlend = leaveLast ? -1 : lowertxt.indexOf("</body");
 552     int htmlpose = lowertxt.indexOf(">", htmlpos),
 553             htmlende = lowertxt.indexOf(">", htmlend);
 554     if (htmlend == -1 && htmlpos == -1)
 555     {
 556       return text;
 557     }
 558     if (htmlend > -1)
 559     {
 560       return text.substring((htmlpos == -1 ? 0 : htmlpose + 1), htmlend);
 561     }
 562     return text.substring(htmlpos == -1 ? 0 : htmlpose + 1);
 563   }
 564
 565   /**
 566    * very simple routine for adding/ensuring html tags are present in text.
 567    *
 568    * @param text
 569    * @return properly html tag enclosed text
 570    */
 571   private String ensureHtmlTagged(String text)
 572   {
 573     if (text == null)
 574     {
 575       return "";
 576     }
 577     String lowertxt = text.toLowerCase();
 578     int htmlpos = lowertxt.indexOf("<body");
 579     int htmlend = lowertxt.indexOf("</body");
 580     int doctype = lowertxt.indexOf("<!doctype");
 581     int xmltype = lowertxt.indexOf("<?xml");
 582     if (htmlend == -1)
 583     {
 584       text = text + "</body></html>";
 585     }
 586     if (htmlpos > -1)
 587     {
 588       if ((doctype > -1 && htmlpos > doctype)
 589               || (xmltype > -1 && htmlpos > xmltype))
 590       {
 591         text = "<html><head></head><body>\n" + text.substring(htmlpos - 1);
 592       }
 593     }
 594     else
 595     {
 596       text = "<html><head></head><body>\n" + text;
 597     }
 598     if (text.indexOf("<meta") > -1)
 599     {
 600       System.err
 601               .println("HTML COntent: \n" + text + "<< END HTML CONTENT\n");
 602
 603     }
 604     return text;
 605   }
 606
 607   /**
 608    * DOCUMENT ME!
 609    *
 610    * @param text
 611    *          DOCUMENT ME!
 612    */
 613   public void appendProgressText(int which, String text)
 614   {
 615     if (jobPanes == null)
 616     {
 617       addJobPane();
 618     }
 619     if (renderAsHtml)
 620     {
 621       String txt = getHtmlFragment(
 622               ((JEditorPane) ((JScrollPane) jobPanes.get(which))
 623                       .getViewport().getComponent(0)).getText(),
 624               true, false);
 625       ((JEditorPane) ((JScrollPane) jobPanes.get(which)).getViewport()
 626               .getComponent(0))
 627                       .setText(ensureHtmlTagged(
 628                               txt + getHtmlFragment(text, false, true)));
 629     }
 630     else
 631     {
 632       ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 633               .getComponent(0)).append(text);
 634     }
 635   }
 636
 637   /**
 638    * setProgressText(0, text)
 639    */
 640   public void setProgressText(String text)
 641   {
 642     setProgressText(0, text);
 643   }
 644
 645   /**
 646    * appendProgressText(0, text)
 647    */
 648   public void appendProgressText(String text)
 649   {
 650     appendProgressText(0, text);
 651   }
 652
 653   /**
 654    * getProgressText(0)
 655    */
 656   public String getProgressText()
 657   {
 658     return getProgressText(0);
 659   }
 660
 661   /**
 662    * get the tab title for a subjob
 663    *
 664    * @param which
 665    *          int
 666    * @return String
 667    */
 668   public String getProgressName(int which)
 669   {
 670     if (jobPanes == null)
 671     {
 672       addJobPane();
 673     }
 674     if (subjobs != null)
 675     {
 676       return subjobs.getTitleAt(which);
 677     }
 678     else
 679     {
 680       return ((JScrollPane) jobPanes.get(which)).getViewport()
 681               .getComponent(0).getName();
 682     }
 683   }
 684
 685   /**
 686    * set the tab title for a subjob
 687    *
 688    * @param name
 689    *          String
 690    * @param which
 691    *          int
 692    */
 693   public void setProgressName(String name, int which)
 694   {
 695     if (subjobs != null)
 696     {
 697       subjobs.setTitleAt(which, name);
 698       subjobs.revalidate();
 699       subjobs.repaint();
 700     }
 701     JScrollPane c = (JScrollPane) jobPanes.get(which);
 702     c.getViewport().getComponent(0).setName(name);
 703     c.repaint();
 704   }
 705
 706   /**
 707    * Gui action for cancelling the current job, if possible.
 708    *
 709    * @param e
 710    *          DOCUMENT ME!
 711    */
 712   @Override
 713   protected void cancel_actionPerformed(ActionEvent e)
 714   {
 715     if (!serviceIsCancellable)
 716     {
 717       // JBPNote : TODO: We should REALLY just tell the WSClientI to cancel
 718       // anyhow - it has to stop threads and clean up
 719       // JBPNote : TODO: Instead of a warning, we should have an optional 'Are
 720       // you sure?' prompt
 721       warnUser(
 722               MessageManager.getString(
 723                       "warn.job_cannot_be_cancelled_close_window"),
 724               MessageManager.getString("action.cancel_job"));
 725     }
 726     else
 727     {
 728       thisService.cancelJob();
 729     }
 730     frame.setClosable(true);
 731   }
 732
 733   /**
 734    * Spawns a thread that pops up a warning dialog box with the given message
 735    * and title.
 736    *
 737    * @param message
 738    * @param title
 739    */
 740   public void warnUser(final String message, final String title)
 741   {
 742     javax.swing.SwingUtilities.invokeLater(new Runnable()
 743     {
 744       @Override
 745       public void run()
 746       {
 747         JvOptionPane.showInternalMessageDialog(Desktop.desktop, message,
 748                 title, JvOptionPane.WARNING_MESSAGE);
 749
 750       }
 751     });
 752   }
 753
 754   /**
 755    * Set up GUI for user to get at results - and possibly automatically display
 756    * them if viewResultsImmediatly is set.
 757    */
 758   public void setResultsReady()
 759   {
 760     frame.setClosable(true);
 761     buttonPanel.remove(cancel);
 762     buttonPanel.add(showResultsNewFrame);
 763     if (serviceCanMergeResults)
 764     {
 765       buttonPanel.add(mergeResults);
 766       buttonPanel.setLayout(new GridLayout(2, 1, 5, 5));
 767     }
 768     buttonPanel.validate();
 769     validate();
 770     if (viewResultsImmediatly)
 771     {
 772       showResultsNewFrame.doClick();
 773     }
 774   }
 775
 776   /**
 777    * called when job has finished but no result objects can be passed back to
 778    * user
 779    */
 780   public void setFinishedNoResults()
 781   {
 782     frame.setClosable(true);
 783     buttonPanel.remove(cancel);
 784     buttonPanel.validate();
 785     validate();
 786   }
 787
 788   class AnimatedPanel extends JPanel implements Runnable
 789   {
 790     long startTime = 0;
 791
 792     BufferedImage offscreen;
 793
 794     @Override
 795     public void run()
 796     {
 797       startTime = System.currentTimeMillis();
 798
 799       float invSpeed = 15f;
 800       float factor = 1f;
 801       while (currentStatus < STATE_STOPPED_OK)
 802       {
 803         if (currentStatus == STATE_QUEUING)
 804         {
 805           invSpeed = 25f;
 806           factor = 1f;
 807         }
 808         else if (currentStatus == STATE_RUNNING)
 809         {
 810           invSpeed = 10f;
 811           factor = (float) (0.5 + 1.5
 812                   * (0.5 - (0.5 * Math.sin(3.14159 / 180 * (angle + 45)))));
 813         }
 814         try
 815         {
 816           Thread.sleep(50);
 817
 818           float delta = (System.currentTimeMillis() - startTime) / invSpeed;
 819           angle += delta * factor;
 820           angle %= 360;
 821           startTime = System.currentTimeMillis();
 822
 823           if (currentStatus >= STATE_STOPPED_OK)
 824           {
 825             park();
 826             angle = 0;
 827           }
 828
 829           repaint();
 830         } catch (Exception ex)
 831         {
 832         }
 833       }
 834
 835       cancel.setEnabled(false);
 836     }
 837
 838     public void park()
 839     {
 840       startTime = System.currentTimeMillis();
 841
 842       while (angle < 360)
 843       {
 844         float invSpeed = 5f;
 845         float factor = 1f;
 846         try
 847         {
 848           Thread.sleep(25);
 849
 850           float delta = (System.currentTimeMillis() - startTime) / invSpeed;
 851           angle += delta * factor;
 852           startTime = System.currentTimeMillis();
 853
 854           if (angle >= 360)
 855           {
 856             angle = 360;
 857           }
 858
 859           repaint();
 860         } catch (Exception ex)
 861         {
 862         }
 863       }
 864
 865     }
 866
 867     void drawPanel()
 868     {
 869       if (offscreen == null || offscreen.getWidth(this) != getWidth()
 870               || offscreen.getHeight(this) != getHeight())
 871       {
 872         offscreen = new BufferedImage(getWidth(), getHeight(),
 873                 BufferedImage.TYPE_INT_RGB);
 874       }
 875
 876       Graphics2D g = (Graphics2D) offscreen.getGraphics();
 877
 878       g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 879               RenderingHints.VALUE_ANTIALIAS_ON);
 880       g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
 881               RenderingHints.VALUE_INTERPOLATION_BICUBIC);
 882       g.setRenderingHint(RenderingHints.KEY_RENDERING,
 883               RenderingHints.VALUE_RENDER_QUALITY);
 884
 885       g.setColor(Color.white);
 886       g.fillRect(0, 0, getWidth(), getHeight());
 887
 888       if (image != null)
 889       {
 890         int x = image.getWidth(this) / 2, y = image.getHeight(this) / 2;
 891         g.rotate(3.14159 / 180 * (angle), x, y);
 892         g.drawImage(image, 0, 0, this);
 893         g.rotate(-3.14159 / 180 * (angle), x, y);
 894       }
 895     }
 896
 897     @Override
 898     public void paintComponent(Graphics g1)
 899     {
 900       drawPanel();
 901
 902       g1.drawImage(offscreen, 0, 0, this);
 903     }
 904   }
 905
 906   boolean renderAsHtml = false;
 907
 908   public void setRenderAsHtml(boolean b)
 909   {
 910     renderAsHtml = b;
 911   }
 912
 913   @Override
 914   public void hyperlinkUpdate(HyperlinkEvent e)
 915   {
 916     Desktop.hyperlinkUpdate(e);
 917   }
 918
 919   /*
 920    * (non-Javadoc)
 921    *
 922    * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
 923    */
 924   @Override
 925   public void setProgressBar(String message, long id)
 926   {
 927     progressBar.setProgressBar(message, id);
 928   }
 929
 930   @Override
 931   public void registerHandler(final long id,
 932           final IProgressIndicatorHandler handler)
 933   {
 934     progressBar.registerHandler(id, handler);
 935   }
 936
 937   /**
 938    *
 939    * @return true if any progress bars are still active
 940    */
 941   @Override
 942   public boolean operationInProgress()
 943   {
 944     return progressBar.operationInProgress();
 945   }
 946 }