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