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
  60         implements 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()
 332             .getResource("/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(
 352             new javax.swing.event.InternalFrameAdapter()
 353             {
 354               public void internalFrameClosed(
 355                       javax.swing.event.InternalFrameEvent evt)
 356               {
 357                 // System.out.println("Shutting down webservice client");
 358                 WSClientI service = thisinfo.getthisService();
 359                 if (service != null && service.isCancellable())
 360                 {
 361                   service.cancelJob();
 362                 }
 363               };
 364             });
 365     frame.validate();
 366
 367   }
 368
 369   /**
 370    * DOCUMENT ME!
 371    *
 372    * @param status
 373    *          integer status from state constants
 374    */
 375   public void setStatus(int status)
 376   {
 377     currentStatus = status;
 378   }
 379
 380   /**
 381    * subjob status indicator
 382    *
 383    * @param jobpane
 384    * @param status
 385    */
 386   public void setStatus(int jobpane, int status)
 387   {
 388     if (jobpane < 0 || jobpane >= jobPanes.size())
 389     {
 390       throw new Error(MessageManager.formatMessage(
 391               "error.setstatus_called_non_existent_job_pane", new String[]
 392               { Integer.valueOf(jobpane).toString() }));
 393     }
 394     switch (status)
 395     {
 396     case STATE_QUEUING:
 397       setProgressName(jobpane + " - QUEUED", jobpane);
 398       break;
 399     case STATE_RUNNING:
 400       setProgressName(jobpane + " - RUNNING", jobpane);
 401       break;
 402     case STATE_STOPPED_OK:
 403       setProgressName(jobpane + " - FINISHED", jobpane);
 404       break;
 405     case STATE_CANCELLED_OK:
 406       setProgressName(jobpane + " - CANCELLED", jobpane);
 407       break;
 408     case STATE_STOPPED_ERROR:
 409       setProgressName(jobpane + " - BROKEN", jobpane);
 410       break;
 411     case STATE_STOPPED_SERVERERROR:
 412       setProgressName(jobpane + " - ALERT", jobpane);
 413       break;
 414     default:
 415       setProgressName(jobpane + " - UNKNOWN STATE", jobpane);
 416     }
 417   }
 418
 419   /**
 420    * DOCUMENT ME!
 421    *
 422    * @return DOCUMENT ME!
 423    */
 424   public String getInfoText()
 425   {
 426     return infoText.getText();
 427   }
 428
 429   /**
 430    * DOCUMENT ME!
 431    *
 432    * @param text
 433    *          DOCUMENT ME!
 434    */
 435   public void setInfoText(String text)
 436   {
 437     infoText.setText(text);
 438   }
 439
 440   /**
 441    * DOCUMENT ME!
 442    *
 443    * @param text
 444    *          DOCUMENT ME!
 445    */
 446   public void appendInfoText(String text)
 447   {
 448     infoText.append(text);
 449   }
 450
 451   /**
 452    * DOCUMENT ME!
 453    *
 454    * @return DOCUMENT ME!
 455    */
 456   public String getProgressText(int which)
 457   {
 458     if (jobPanes == null)
 459     {
 460       addJobPane();
 461     }
 462     if (renderAsHtml)
 463     {
 464       return ((JEditorPane) ((JScrollPane) jobPanes.get(which))
 465               .getViewport().getComponent(0)).getText();
 466     }
 467     else
 468     {
 469       return ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 470               .getComponent(0)).getText();
 471     }
 472   }
 473
 474   /**
 475    * DOCUMENT ME!
 476    *
 477    * @param text
 478    *          DOCUMENT ME!
 479    */
 480   public void setProgressText(int which, String text)
 481   {
 482     if (jobPanes == null)
 483     {
 484       addJobPane();
 485     }
 486     if (renderAsHtml)
 487     {
 488       ((JEditorPane) ((JScrollPane) jobPanes.get(which)).getViewport()
 489               .getComponent(0)).setText(ensureHtmlTagged(text));
 490     }
 491     else
 492     {
 493       ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 494               .getComponent(0)).setText(text);
 495     }
 496   }
 497
 498   /**
 499    * extract content from &lt;body&gt; content &lt;/body&gt;
 500    *
 501    * @param text
 502    * @param leaveFirst
 503    *          - set to leave the initial html tag intact
 504    * @param leaveLast
 505    *          - set to leave the final html tag intact
 506    * @return
 507    */
 508   private String getHtmlFragment(String text, boolean leaveFirst,
 509           boolean leaveLast)
 510   {
 511     if (text == null)
 512     {
 513       return null;
 514     }
 515     String lowertxt = text.toLowerCase();
 516     int htmlpos = leaveFirst ? -1 : lowertxt.indexOf("<body");
 517
 518     int htmlend = leaveLast ? -1 : lowertxt.indexOf("</body");
 519     int htmlpose = lowertxt.indexOf(">", htmlpos),
 520             htmlende = lowertxt.indexOf(">", htmlend);
 521     if (htmlend == -1 && htmlpos == -1)
 522     {
 523       return text;
 524     }
 525     if (htmlend > -1)
 526     {
 527       return text.substring((htmlpos == -1 ? 0 : htmlpose + 1), htmlend);
 528     }
 529     return text.substring(htmlpos == -1 ? 0 : htmlpose + 1);
 530   }
 531
 532   /**
 533    * very simple routine for adding/ensuring html tags are present in text.
 534    *
 535    * @param text
 536    * @return properly html tag enclosed text
 537    */
 538   private String ensureHtmlTagged(String text)
 539   {
 540     if (text == null)
 541     {
 542       return "";
 543     }
 544     String lowertxt = text.toLowerCase();
 545     int htmlpos = lowertxt.indexOf("<body");
 546     int htmlend = lowertxt.indexOf("</body");
 547     int doctype = lowertxt.indexOf("<!doctype");
 548     int xmltype = lowertxt.indexOf("<?xml");
 549     if (htmlend == -1)
 550     {
 551       text = text + "</body></html>";
 552     }
 553     if (htmlpos > -1)
 554     {
 555       if ((doctype > -1 && htmlpos > doctype)
 556               || (xmltype > -1 && htmlpos > xmltype))
 557       {
 558         text = "<html><head></head><body>\n" + text.substring(htmlpos - 1);
 559       }
 560     }
 561     else
 562     {
 563       text = "<html><head></head><body>\n" + text;
 564     }
 565     if (text.indexOf("<meta") > -1)
 566     {
 567       System.err
 568               .println("HTML COntent: \n" + text + "<< END HTML CONTENT\n");
 569
 570     }
 571     return text;
 572   }
 573
 574   /**
 575    * DOCUMENT ME!
 576    *
 577    * @param text
 578    *          DOCUMENT ME!
 579    */
 580   public void appendProgressText(int which, String text)
 581   {
 582     if (jobPanes == null)
 583     {
 584       addJobPane();
 585     }
 586     if (renderAsHtml)
 587     {
 588       String txt = getHtmlFragment(
 589               ((JEditorPane) ((JScrollPane) jobPanes.get(which))
 590                       .getViewport().getComponent(0)).getText(),
 591               true, false);
 592       ((JEditorPane) ((JScrollPane) jobPanes.get(which)).getViewport()
 593               .getComponent(0))
 594                       .setText(ensureHtmlTagged(
 595                               txt + getHtmlFragment(text, false, true)));
 596     }
 597     else
 598     {
 599       ((JTextArea) ((JScrollPane) jobPanes.get(which)).getViewport()
 600               .getComponent(0)).append(text);
 601     }
 602   }
 603
 604   /**
 605    * setProgressText(0, text)
 606    */
 607   public void setProgressText(String text)
 608   {
 609     setProgressText(0, text);
 610   }
 611
 612   /**
 613    * appendProgressText(0, text)
 614    */
 615   public void appendProgressText(String text)
 616   {
 617     appendProgressText(0, text);
 618   }
 619
 620   /**
 621    * getProgressText(0)
 622    */
 623   public String getProgressText()
 624   {
 625     return getProgressText(0);
 626   }
 627
 628   /**
 629    * get the tab title for a subjob
 630    *
 631    * @param which
 632    *          int
 633    * @return String
 634    */
 635   public String getProgressName(int which)
 636   {
 637     if (jobPanes == null)
 638     {
 639       addJobPane();
 640     }
 641     if (subjobs != null)
 642     {
 643       return subjobs.getTitleAt(which);
 644     }
 645     else
 646     {
 647       return ((JScrollPane) jobPanes.get(which)).getViewport()
 648               .getComponent(0).getName();
 649     }
 650   }
 651
 652   /**
 653    * set the tab title for a subjob
 654    *
 655    * @param name
 656    *          String
 657    * @param which
 658    *          int
 659    */
 660   public void setProgressName(String name, int which)
 661   {
 662     if (subjobs != null)
 663     {
 664       subjobs.setTitleAt(which, name);
 665       subjobs.revalidate();
 666       subjobs.repaint();
 667     }
 668     JScrollPane c = (JScrollPane) jobPanes.get(which);
 669     c.getViewport().getComponent(0).setName(name);
 670     c.repaint();
 671   }
 672
 673   /**
 674    * Gui action for cancelling the current job, if possible.
 675    *
 676    * @param e
 677    *          DOCUMENT ME!
 678    */
 679   protected void cancel_actionPerformed(ActionEvent e)
 680   {
 681     if (!serviceIsCancellable)
 682     {
 683       // JBPNote : TODO: We should REALLY just tell the WSClientI to cancel
 684       // anyhow - it has to stop threads and clean up
 685       // JBPNote : TODO: Instead of a warning, we should have an optional 'Are
 686       // you sure?' prompt
 687       warnUser(
 688               MessageManager.getString(
 689                       "warn.job_cannot_be_cancelled_close_window"),
 690               MessageManager.getString("action.cancel_job"));
 691     }
 692     else
 693     {
 694       thisService.cancelJob();
 695     }
 696     frame.setClosable(true);
 697   }
 698
 699   /**
 700    * Spawns a thread that pops up a warning dialog box with the given message
 701    * and title.
 702    *
 703    * @param message
 704    * @param title
 705    */
 706   public void warnUser(final String message, final String title)
 707   {
 708     javax.swing.SwingUtilities.invokeLater(new Runnable()
 709     {
 710       public void run()
 711       {
 712         JvOptionPane.showInternalMessageDialog(Desktop.desktop, message,
 713                 title, JvOptionPane.WARNING_MESSAGE);
 714
 715       }
 716     });
 717   }
 718
 719   /**
 720    * Set up GUI for user to get at results - and possibly automatically display
 721    * them if viewResultsImmediatly is set.
 722    */
 723   public void setResultsReady()
 724   {
 725     frame.setClosable(true);
 726     buttonPanel.remove(cancel);
 727     buttonPanel.add(showResultsNewFrame);
 728     if (serviceCanMergeResults)
 729     {
 730       buttonPanel.add(mergeResults);
 731       buttonPanel.setLayout(new GridLayout(2, 1, 5, 5));
 732     }
 733     buttonPanel.validate();
 734     validate();
 735     if (viewResultsImmediatly)
 736     {
 737       showResultsNewFrame.doClick();
 738     }
 739   }
 740
 741   /**
 742    * called when job has finished but no result objects can be passed back to
 743    * user
 744    */
 745   public void setFinishedNoResults()
 746   {
 747     frame.setClosable(true);
 748     buttonPanel.remove(cancel);
 749     buttonPanel.validate();
 750     validate();
 751   }
 752
 753   class AnimatedPanel extends JPanel implements Runnable
 754   {
 755     long startTime = 0;
 756
 757     BufferedImage offscreen;
 758
 759     public void run()
 760     {
 761       startTime = System.currentTimeMillis();
 762
 763       while (currentStatus < STATE_STOPPED_OK)
 764       {
 765         try
 766         {
 767           Thread.sleep(50);
 768
 769           int units = (int) ((System.currentTimeMillis() - startTime)
 770                   / 10f);
 771           angle += units;
 772           angle %= 360;
 773           startTime = System.currentTimeMillis();
 774
 775           if (currentStatus >= STATE_STOPPED_OK)
 776           {
 777             angle = 0;
 778           }
 779
 780           repaint();
 781         } catch (Exception ex)
 782         {
 783         }
 784       }
 785
 786       cancel.setEnabled(false);
 787     }
 788
 789     void drawPanel()
 790     {
 791       if (offscreen == null || offscreen.getWidth(this) != getWidth()
 792               || offscreen.getHeight(this) != getHeight())
 793       {
 794         offscreen = new BufferedImage(getWidth(), getHeight(),
 795                 BufferedImage.TYPE_INT_ARGB);
 796       }
 797
 798       Graphics2D g = (Graphics2D) offscreen.getGraphics();
 799
 800       g.setColor(Color.white);
 801       g.fillRect(0, 0, getWidth(), getHeight());
 802
 803       g.setFont(new Font("Arial", Font.BOLD, 12));
 804       g.setColor(Color.black);
 805
 806       switch (currentStatus)
 807       {
 808       case STATE_QUEUING:
 809         g.drawString(
 810                 title.concat(" - ").concat(
 811                         MessageManager.getString("label.state_queueing")),
 812                 60, 30);
 813
 814         break;
 815
 816       case STATE_RUNNING:
 817         g.drawString(
 818                 title.concat(" - ").concat(
 819                         MessageManager.getString("label.state_running")),
 820                 60, 30);
 821
 822         break;
 823
 824       case STATE_STOPPED_OK:
 825         g.drawString(
 826                 title.concat(" - ").concat(
 827                         MessageManager.getString("label.state_completed")),
 828                 60, 30);
 829
 830         break;
 831
 832       case STATE_CANCELLED_OK:
 833         g.drawString(
 834                 title.concat(" - ")
 835                         .concat(MessageManager
 836                                 .getString("label.state_job_cancelled")),
 837                 60, 30);
 838
 839         break;
 840
 841       case STATE_STOPPED_ERROR:
 842         g.drawString(
 843                 title.concat(" - ").concat(
 844                         MessageManager.getString("label.state_job_error")),
 845                 60, 30);
 846
 847         break;
 848
 849       case STATE_STOPPED_SERVERERROR:
 850         g.drawString(
 851                 title.concat(" - ")
 852                         .concat(MessageManager
 853                                 .getString("label.server_error_try_later")),
 854                 60, 30);
 855
 856         break;
 857       }
 858
 859       if (image != null)
 860       {
 861         int x = image.getWidth(this) / 2, y = image.getHeight(this) / 2;
 862         g.rotate(Math.toRadians(angle), 10 + x, 10 + y);
 863         g.drawImage(image, 10, 10, this);
 864         g.rotate(-Math.toRadians(angle), 10 + x, 10 + y);
 865       }
 866     }
 867
 868     public void paintComponent(Graphics g1)
 869     {
 870       drawPanel();
 871
 872       g1.drawImage(offscreen, 0, 0, this);
 873     }
 874   }
 875
 876   boolean renderAsHtml = false;
 877
 878   public void setRenderAsHtml(boolean b)
 879   {
 880     renderAsHtml = b;
 881   }
 882
 883   public void hyperlinkUpdate(HyperlinkEvent e)
 884   {
 885     Desktop.hyperlinkUpdate(e);
 886   }
 887
 888   /*
 889    * (non-Javadoc)
 890    *
 891    * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
 892    */
 893   @Override
 894   public void setProgressBar(String message, long id)
 895   {
 896     progressBar.setProgressBar(message, id);
 897   }
 898
 899   @Override
 900   public void registerHandler(final long id,
 901           final IProgressIndicatorHandler handler)
 902   {
 903     progressBar.registerHandler(id, handler);
 904   }
 905
 906   /**
 907    *
 908    * @return true if any progress bars are still active
 909    */
 910   @Override
 911   public boolean operationInProgress()
 912   {
 913     return progressBar.operationInProgress();
 914   }
 915 }