Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[jalview.git] / 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 }