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