d9d729ab93a3ae0fed7d348ce704e493a608af58
[jalview.git] / src / jalview / gui / Console.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.GraphicsEnvironment;
27 import java.awt.GridBagConstraints;
28 import java.awt.GridBagLayout;
29 import java.awt.Rectangle;
30 import java.awt.Toolkit;
31 import java.awt.datatransfer.Clipboard;
32 import java.awt.datatransfer.StringSelection;
33 import java.awt.event.ActionEvent;
34 import java.awt.event.ActionListener;
35 import java.awt.event.MouseAdapter;
36 import java.awt.event.MouseEvent;
37 import java.awt.event.WindowAdapter;
38 import java.awt.event.WindowEvent;
39 import java.awt.event.WindowListener;
40 import java.io.IOException;
41 import java.io.PipedInputStream;
42 import java.io.PipedOutputStream;
43 import java.io.PrintStream;
44
45 import javax.swing.BorderFactory;
46 import javax.swing.JButton;
47 import javax.swing.JComboBox;
48 import javax.swing.JFrame;
49 import javax.swing.JLabel;
50 import javax.swing.JPanel;
51 import javax.swing.JScrollPane;
52 import javax.swing.JTextArea;
53 import javax.swing.border.Border;
54 import javax.swing.text.DefaultCaret;
55
56 import jalview.log.JLoggerI.LogLevel;
57 import jalview.log.JLoggerLog4j;
58 import jalview.log.JalviewAppender;
59 import jalview.util.ChannelProperties;
60 import jalview.util.MessageManager;
61 import jalview.util.Platform;
62
63 /**
64  * Simple Jalview Java Console. Version 1 - allows viewing of console output
65  * after desktop is created. Acquired with thanks from RJHM's site
66  * http://www.comweb.nl/java/Console/Console.html A simple Java Console for your
67  * application (Swing version) Requires Java 1.1.5 or higher Disclaimer the use
68  * of this source is at your own risk. Permision to use and distribute into your
69  * own applications RJHM van den Bergh , rvdb@comweb.nl
70  */
71
72 public class Console extends WindowAdapter
73         implements WindowListener, ActionListener, Runnable
74 {
75   private JFrame frame;
76
77   private JTextArea textArea;
78
79   /*
80    * unused - tally and limit for lines in console window int lines = 0;
81    * 
82    * int lim = 1000;
83    */
84   int byteslim = 102400, bytescut = 76800; // 100k and 75k cut point.
85
86   private Thread reader, reader2, textAppender;
87
88   private boolean quit;
89
90   private final PrintStream stdout = System.out, stderr = System.err;
91
92   private PipedInputStream pin = new PipedInputStream();
93
94   private PipedInputStream pin2 = new PipedInputStream();
95
96   private StringBuffer displayPipe = new StringBuffer();
97
98   Thread errorThrower; // just for testing (Throws an Exception at this Console
99
100   // are we attached to some parent Desktop
101   Desktop parent = null;
102
103   private int MIN_WIDTH = 300;
104
105   private int MIN_HEIGHT = 250;
106
107   private JComboBox<LogLevel> logLevelCombo = new JComboBox<LogLevel>();
108
109   protected LogLevel startingLogLevel = LogLevel.INFO;
110
111   public Console()
112   {
113     // create all components and add them
114     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
115     frame = initFrame("Java Console", screenSize.width / 2,
116             screenSize.height / 2, -1, -1);
117     initConsole(true);
118   }
119
120   private void initConsole(boolean visible)
121   {
122     initConsole(visible, true);
123   }
124
125   /**
126    * 
127    * @param visible
128    *          - open the window
129    * @param redirect
130    *          - redirect std*
131    */
132   private void initConsole(boolean visible, boolean redirect)
133   {
134     // CutAndPasteTransfer cpt = new CutAndPasteTransfer();
135     // textArea = cpt.getTextArea();
136     textArea = new JTextArea();
137     textArea.setEditable(false);
138     // autoscroll
139     DefaultCaret caret = (DefaultCaret) textArea.getCaret();
140     caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE);
141     // toggle autoscroll by clicking on the text area
142     Border pausedBorder = BorderFactory.createMatteBorder(2, 2, 2, 2,
143             textArea.getForeground());
144     Border noBorder = BorderFactory.createEmptyBorder(2, 2, 2, 2);
145     JScrollPane scrollPane = new JScrollPane(textArea);
146     scrollPane.setBorder(noBorder);
147     textArea.addMouseListener(new MouseAdapter()
148     {
149       public void mouseClicked(MouseEvent e)
150       {
151         if (e.getButton() == MouseEvent.BUTTON1)
152         {
153           if (caret.getUpdatePolicy() == DefaultCaret.ALWAYS_UPDATE)
154           {
155             caret.setUpdatePolicy(DefaultCaret.NEVER_UPDATE);
156             scrollPane.setBorder(pausedBorder);
157           }
158           else
159           {
160             caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE);
161             textArea.setCaretPosition(textArea.getDocument().getLength());
162             scrollPane.setBorder(noBorder);
163           }
164         }
165       }
166     });
167
168     JButton clearButton = new JButton(
169             MessageManager.getString("action.clear"));
170     JButton copyToClipboardButton = new JButton(
171             MessageManager.getString("label.copy_to_clipboard"));
172     copyToClipboardButton.addActionListener(new ActionListener()
173     {
174       public void actionPerformed(ActionEvent e)
175       {
176         copyConsoleTextToClipboard();
177       }
178     });
179     copyToClipboardButton.addMouseListener(new MouseAdapter()
180     {
181       private Color bg = textArea.getBackground();
182
183       private Color fg = textArea.getForeground();
184
185       public void mousePressed(MouseEvent e)
186       {
187         textArea.setBackground(textArea.getSelectionColor());
188         textArea.setForeground(textArea.getSelectedTextColor());
189       }
190
191       public void mouseReleased(MouseEvent e)
192       {
193         textArea.setBackground(bg);
194         textArea.setForeground(fg);
195       }
196
197     });
198     copyToClipboardButton.setToolTipText(
199             MessageManager.getString("label.copy_to_clipboard_tooltip"));
200
201     JLabel logLevelLabel = new JLabel(
202             MessageManager.getString("label.log_level") + ":");
203
204     // logLevelCombo.addItem(LogLevel.ALL);
205     logLevelCombo.addItem(LogLevel.TRACE);
206     logLevelCombo.addItem(LogLevel.DEBUG);
207     logLevelCombo.addItem(LogLevel.INFO);
208     logLevelCombo.addItem(LogLevel.WARN);
209     // logLevelCombo.addItem(LogLevel.ERROR);
210     // logLevelCombo.addItem(LogLevel.FATAL);
211     // logLevelCombo.addItem(LogLevel.ERROR);
212     // logLevelCombo.addItem(LogLevel.OFF);
213     // set startingLogLevel
214     startingLogLevel = jalview.bin.Console.log == null ? LogLevel.INFO
215             : jalview.bin.Console.log.getLevel();
216     setChosenLogLevelCombo();
217     logLevelCombo.addActionListener(new ActionListener()
218     {
219       public void actionPerformed(ActionEvent e)
220       {
221         if (jalview.bin.Console.log != null)
222         {
223           jalview.bin.Console.log.setLevel((LogLevel) logLevelCombo.getSelectedItem());
224         }
225       }
226
227     });
228
229     // frame = cpt;
230     frame.getContentPane().setLayout(new BorderLayout());
231     frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
232     JPanel southPanel = new JPanel();
233     southPanel.setLayout(new GridBagLayout());
234
235     JPanel logLevelPanel = new JPanel();
236     logLevelPanel.setAlignmentX(JPanel.LEFT_ALIGNMENT);
237     logLevelPanel.add(logLevelLabel);
238     logLevelPanel.add(logLevelCombo);
239     String logLevelTooltip = MessageManager.formatMessage(
240             "label.log_level_tooltip", startingLogLevel.toString());
241     logLevelLabel.setToolTipText(logLevelTooltip);
242     logLevelCombo.setToolTipText(logLevelTooltip);
243
244     GridBagConstraints gbc = new GridBagConstraints();
245     gbc.gridx = 0;
246     gbc.gridy = 0;
247     gbc.gridwidth = 1;
248     gbc.gridheight = 1;
249     gbc.weightx = 0.1;
250     southPanel.add(logLevelPanel, gbc);
251
252     gbc.gridx++;
253     gbc.weightx = 0.8;
254     gbc.fill = GridBagConstraints.HORIZONTAL;
255     southPanel.add(clearButton, gbc);
256
257     gbc.gridx++;
258     gbc.weightx = 0.1;
259     gbc.fill = GridBagConstraints.NONE;
260     southPanel.add(copyToClipboardButton, gbc);
261
262     southPanel.setVisible(true);
263     frame.getContentPane().add(southPanel, BorderLayout.SOUTH);
264     frame.setVisible(visible);
265     updateConsole = visible;
266     frame.addWindowListener(this);
267     clearButton.addActionListener(this);
268
269     if (redirect)
270     {
271       redirectStreams();
272     }
273     else
274     {
275       unredirectStreams();
276     }
277     quit = false; // signals the Threads that they should exit
278
279     // Starting two seperate threads to read from the PipedInputStreams
280     //
281     reader = new Thread(this);
282     reader.setDaemon(true);
283     reader.start();
284     //
285     reader2 = new Thread(this);
286     reader2.setDaemon(true);
287     reader2.start();
288     // and a thread to append text to the textarea
289     textAppender = new Thread(this);
290     textAppender.setDaemon(true);
291     textAppender.start();
292
293     // set icons
294     frame.setIconImages(ChannelProperties.getIconList());
295   }
296
297   private void setChosenLogLevelCombo()
298   {
299     setChosenLogLevelCombo(startingLogLevel);
300   }
301
302   private void setChosenLogLevelCombo(LogLevel setLogLevel)
303   {
304     logLevelCombo.setSelectedItem(setLogLevel);
305     if (!logLevelCombo.getSelectedItem().equals(setLogLevel))
306     {
307       // setLogLevel not (yet) in list
308       if (setLogLevel != null && setLogLevel instanceof LogLevel)
309       {
310         // add new item to list (might be set via .jalview_properties)
311         boolean added = false;
312         for (int i = 0; i < logLevelCombo.getItemCount(); i++)
313         {
314           LogLevel l = (LogLevel) logLevelCombo.getItemAt(i);
315           if (l.compareTo(setLogLevel) >= 0)
316           {
317             logLevelCombo.insertItemAt(setLogLevel, i);
318             added = true;
319             break;
320           }
321         }
322         if (!added) // lower priority than others or some confusion -- add to
323                     // end of list
324         {
325           logLevelCombo.addItem(setLogLevel);
326         }
327         logLevelCombo.setSelectedItem(setLogLevel);
328       }
329       else
330       {
331         logLevelCombo.setSelectedItem(LogLevel.INFO);
332       }
333     }
334   }
335
336   private void copyConsoleTextToClipboard()
337   {
338     String consoleText = textArea.getText();
339     StringSelection consoleTextSelection = new StringSelection(consoleText);
340     Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
341     cb.setContents(consoleTextSelection, null);
342   }
343
344   PipedOutputStream pout = null, perr = null;
345
346   public void redirectStreams()
347   {
348     if (pout == null)
349     {
350       try
351       {
352         pout = new PipedOutputStream(this.pin);
353         System.setOut(new PrintStream(pout, true));
354       } catch (java.io.IOException io)
355       {
356         textArea.append("Couldn't redirect STDOUT to this console\n"
357                 + io.getMessage());
358         io.printStackTrace(stderr);
359       } catch (SecurityException se)
360       {
361         textArea.append("Couldn't redirect STDOUT to this console\n"
362                 + se.getMessage());
363         se.printStackTrace(stderr);
364       }
365
366       try
367       {
368         perr = new PipedOutputStream(this.pin2);
369         System.setErr(new PrintStream(perr, true));
370       } catch (java.io.IOException io)
371       {
372         textArea.append("Couldn't redirect STDERR to this console\n"
373                 + io.getMessage());
374         io.printStackTrace(stderr);
375       } catch (SecurityException se)
376       {
377         textArea.append("Couldn't redirect STDERR to this console\n"
378                 + se.getMessage());
379         se.printStackTrace(stderr);
380       }
381     }
382   }
383
384   public void unredirectStreams()
385   {
386     if (pout != null)
387     {
388       try
389       {
390         System.setOut(stdout);
391         pout.flush();
392         pout.close();
393         pin = new PipedInputStream();
394         pout = null;
395       } catch (java.io.IOException io)
396       {
397         textArea.append("Couldn't unredirect STDOUT to this console\n"
398                 + io.getMessage());
399         io.printStackTrace(stderr);
400       } catch (SecurityException se)
401       {
402         textArea.append("Couldn't unredirect STDOUT to this console\n"
403                 + se.getMessage());
404         se.printStackTrace(stderr);
405       }
406
407       try
408       {
409         System.setErr(stderr);
410         perr.flush();
411         perr.close();
412         pin2 = new PipedInputStream();
413         perr = null;
414       } catch (java.io.IOException io)
415       {
416         textArea.append("Couldn't unredirect STDERR to this console\n"
417                 + io.getMessage());
418         io.printStackTrace(stderr);
419       } catch (SecurityException se)
420       {
421         textArea.append("Couldn't unredirect STDERR to this console\n"
422                 + se.getMessage());
423         se.printStackTrace(stderr);
424       }
425     }
426   }
427
428   public void test()
429   {
430     // testing part
431     // you may omit this part for your application
432     //
433
434     System.out.println("Hello World 2");
435     System.out.println("All fonts available to Graphic2D:\n");
436     GraphicsEnvironment ge = GraphicsEnvironment
437             .getLocalGraphicsEnvironment();
438     String[] fontNames = ge.getAvailableFontFamilyNames();
439     for (int n = 0; n < fontNames.length; n++)
440     {
441       System.out.println(fontNames[n]);
442     }
443     // Testing part: simple an error thrown anywhere in this JVM will be printed
444     // on the Console
445     // We do it with a seperate Thread becasue we don't wan't to break a Thread
446     // used by the Console.
447     System.out.println("\nLets throw an error on this console");
448     errorThrower = new Thread(this);
449     errorThrower.setDaemon(true);
450     errorThrower.start();
451   }
452
453   private JFrame initFrame(String string, int i, int j, int x, int y)
454   {
455     JFrame frame = new JFrame(string);
456     frame.setName(string);
457     if (x == -1)
458     {
459       x = i / 2;
460     }
461     if (y == -1)
462     {
463       y = j / 2;
464     }
465     frame.setBounds(x, y, i, j);
466     return frame;
467   }
468
469   /**
470    * attach a console to the desktop - the desktop will open it if requested.
471    * 
472    * @param desktop
473    */
474   public Console(Desktop desktop)
475   {
476     this(desktop, true);
477   }
478
479   /**
480    * attach a console to the desktop - the desktop will open it if requested.
481    * 
482    * @param desktop
483    * @param showjconsole
484    *          - if true, then redirect stdout immediately
485    */
486   public Console(Desktop desktop, boolean showjconsole)
487   {
488     parent = desktop;
489     // window name - get x,y,width, height possibly scaled
490     Rectangle bounds = desktop.getLastKnownDimensions("JAVA_CONSOLE_");
491     if (bounds == null)
492     {
493       frame = initFrame(
494               ChannelProperties.getProperty("app_name") + " Java Console",
495               desktop.getWidth() / 2, desktop.getHeight() / 4,
496               desktop.getX(), desktop.getY());
497     }
498     else
499     {
500       frame = initFrame(
501               ChannelProperties.getProperty("app_name") + " Java Console",
502               bounds.width, bounds.height, bounds.x, bounds.y);
503     }
504     frame.setMinimumSize(new Dimension(MIN_WIDTH, MIN_HEIGHT));
505     // desktop.add(frame);
506     initConsole(false);
507     LogLevel level = (LogLevel) logLevelCombo.getSelectedItem();
508     if (!Platform.isJS())
509     {
510       JalviewAppender jappender = new JalviewAppender(level);
511       JalviewAppender.setTextArea(textArea);
512       jappender.start();
513       if (jalview.bin.Console.log != null && jalview.bin.Console.log instanceof JLoggerLog4j)
514       {
515         JLoggerLog4j.addAppender(jalview.bin.Console.log, jappender);
516       }
517     }
518   }
519
520   public synchronized void stopConsole()
521   {
522     quit = true;
523     this.notifyAll();
524     /*
525      * reader.notify(); reader2.notify(); if (errorThrower!=null)
526      * errorThrower.notify(); // stop all threads if (textAppender!=null)
527      * textAppender.notify();
528      */
529     if (pout != null)
530     {
531       try
532       {
533         reader.join(10);
534         pin.close();
535       } catch (Exception e)
536       {
537       }
538       try
539       {
540         reader2.join(10);
541         pin2.close();
542       } catch (Exception e)
543       {
544       }
545       try
546       {
547         textAppender.join(10);
548       } catch (Exception e)
549       {
550       }
551     }
552     if (!frame.isVisible())
553     {
554       frame.dispose();
555     }
556     // System.exit(0);
557   }
558
559   @Override
560   public synchronized void windowClosed(WindowEvent evt)
561   {
562     frame.setVisible(false);
563     closeConsoleGui();
564   }
565
566   private void closeConsoleGui()
567   {
568     updateConsole = false;
569     if (parent == null)
570     {
571
572       stopConsole();
573     }
574     else
575     {
576       parent.showConsole(false);
577     }
578   }
579
580   @Override
581   public synchronized void windowClosing(WindowEvent evt)
582   {
583     frame.setVisible(false); // default behaviour of JFrame
584     closeConsoleGui();
585
586     // frame.dispose();
587   }
588
589   @Override
590   public synchronized void actionPerformed(ActionEvent evt)
591   {
592     trimBuffer(true);
593     // textArea.setText("");
594   }
595
596   @Override
597   public synchronized void run()
598   {
599     try
600     {
601       while (Thread.currentThread() == reader)
602       {
603         if (pin == null || pin.available() == 0)
604         {
605           try
606           {
607             this.wait(100);
608             if (pin.available() == 0)
609             {
610               trimBuffer(false);
611             }
612           } catch (InterruptedException ie)
613           {
614           }
615         }
616
617         while (pin.available() != 0)
618         {
619           String input = this.readLine(pin);
620           stdout.print(input);
621           long time = System.nanoTime();
622           appendToTextArea(input);
623           // stderr.println("Time taken to stdout append:\t"
624           // + (System.nanoTime() - time) + " ns");
625           // lines++;
626         }
627         if (quit)
628         {
629           return;
630         }
631       }
632
633       while (Thread.currentThread() == reader2)
634       {
635         if (pin2.available() == 0)
636         {
637           try
638           {
639             this.wait(100);
640             if (pin2.available() == 0)
641             {
642               trimBuffer(false);
643             }
644           } catch (InterruptedException ie)
645           {
646           }
647         }
648         while (pin2.available() != 0)
649         {
650           String input = this.readLine(pin2);
651           stderr.print(input);
652           long time = System.nanoTime();
653           appendToTextArea(input);
654           // stderr.println("Time taken to stderr append:\t"
655           // + (System.nanoTime() - time) + " ns");
656           // lines++;
657         }
658         if (quit)
659         {
660           return;
661         }
662       }
663       while (Thread.currentThread() == textAppender)
664       {
665         if (updateConsole)
666         {
667           // check string buffer - if greater than console, clear console and
668           // replace with last segment of content, otherwise, append all to
669           // content.
670           long count;
671           while (displayPipe.length() > 0)
672           {
673             count = 0;
674             StringBuffer tmp = new StringBuffer(), replace;
675             synchronized (displayPipe)
676             {
677               replace = displayPipe;
678               displayPipe = tmp;
679             }
680             // simply append whole buffer
681             textArea.append(replace.toString());
682             count += replace.length();
683             if (count > byteslim)
684             {
685               trimBuffer(false);
686             }
687           }
688           if (displayPipe.length() == 0)
689           {
690             try
691             {
692               this.wait(100);
693               if (displayPipe.length() == 0)
694               {
695                 trimBuffer(false);
696               }
697             } catch (InterruptedException e)
698             {
699             }
700           }
701         }
702         else
703         {
704           try
705           {
706             this.wait(100);
707           } catch (InterruptedException e)
708           {
709
710           }
711         }
712         if (quit)
713         {
714           return;
715         }
716
717       }
718     } catch (Exception e)
719     {
720       textArea.append("\nConsole reports an Internal error.");
721       textArea.append("The error is: " + e.getMessage());
722       // Need to uncomment this to ensure that line tally is synched.
723       // lines += 2;
724       stderr.println(
725               "Console reports an Internal error.\nThe error is: " + e);
726     }
727
728     // just for testing (Throw a Nullpointer after 1 second)
729     if (Thread.currentThread() == errorThrower)
730     {
731       try
732       {
733         this.wait(1000);
734       } catch (InterruptedException ie)
735       {
736       }
737       throw new NullPointerException(
738               MessageManager.getString("exception.application_test_npe"));
739     }
740   }
741
742   private void appendToTextArea(final String input)
743   {
744     if (updateConsole == false)
745     {
746       // do nothing;
747       return;
748     }
749     long time = System.nanoTime();
750     javax.swing.SwingUtilities.invokeLater(new Runnable()
751     {
752       @Override
753       public void run()
754       {
755         displayPipe.append(input); // change to stringBuffer
756         // displayPipe.flush();
757
758       }
759     });
760     // stderr.println("Time taken to Spawnappend:\t" + (System.nanoTime() -
761     // time)
762     // + " ns");
763   }
764
765   private String header = null;
766
767   private boolean updateConsole = false;
768
769   private synchronized void trimBuffer(boolean clear)
770   {
771     if (header == null && textArea.getLineCount() > 5)
772     {
773       try
774       {
775         header = textArea.getText(0, textArea.getLineStartOffset(5))
776                 + "\nTruncated...\n";
777       } catch (Exception e)
778       {
779         e.printStackTrace();
780       }
781     }
782     // trim the buffer
783     int tlength = textArea.getDocument().getLength();
784     if (header != null)
785     {
786       if (clear || (tlength > byteslim))
787       {
788         try
789         {
790           if (!clear)
791           {
792             long time = System.nanoTime();
793             textArea.replaceRange(header, 0, tlength - bytescut);
794             // stderr.println("Time taken to cut:\t"
795             // + (System.nanoTime() - time) + " ns");
796           }
797           else
798           {
799             textArea.setText(header);
800           }
801         } catch (Exception e)
802         {
803           e.printStackTrace();
804         }
805         // lines = textArea.getLineCount();
806       }
807     }
808
809   }
810
811   public synchronized String readLine(PipedInputStream in)
812           throws IOException
813   {
814     String input = "";
815     int lp = -1;
816     do
817     {
818       int available = in.available();
819       if (available == 0)
820       {
821         break;
822       }
823       byte b[] = new byte[available];
824       in.read(b);
825       input = input + new String(b, 0, b.length);
826       // counts lines - we don't do this for speed.
827       // while ((lp = input.indexOf("\n", lp + 1)) > -1)
828       // {
829       // lines++;
830       // }
831     } while (!input.endsWith("\n") && !input.endsWith("\r\n") && !quit);
832     return input;
833   }
834
835   /**
836    * @j2sIgnore
837    * @param arg
838    */
839   public static void main(String[] arg)
840   {
841     new Console().test(); // create console with not reference
842
843   }
844
845   public void setVisible(boolean selected)
846   {
847     frame.setVisible(selected);
848     if (selected == true)
849     {
850       setChosenLogLevelCombo();
851       redirectStreams();
852       updateConsole = true;
853       frame.toFront();
854     }
855     else
856     {
857       // reset log level to what it was before
858       if (jalview.bin.Console.log != null)
859       {
860         jalview.bin.Console.log.setLevel(startingLogLevel);
861       }
862
863       unredirectStreams();
864       updateConsole = false;
865     }
866   }
867
868   public Rectangle getBounds()
869   {
870     if (frame != null)
871     {
872       return frame.getBounds();
873     }
874     return null;
875   }
876
877   /**
878    * set the banner that appears at the top of the console output
879    * 
880    * @param string
881    */
882   public void setHeader(String string)
883   {
884     header = string;
885     if (header.charAt(header.length() - 1) != '\n')
886     {
887       header += "\n";
888     }
889     textArea.insert(header, 0);
890   }
891
892   /**
893    * get the banner
894    * 
895    * @return
896    */
897   public String getHeader()
898   {
899     return header;
900   }
901 }