JAL-2416 allow space in score matrix name
[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 jalview.util.MessageManager;
24
25 import java.awt.BorderLayout;
26 import java.awt.Dimension;
27 import java.awt.GraphicsEnvironment;
28 import java.awt.Rectangle;
29 import java.awt.Toolkit;
30 import java.awt.event.ActionEvent;
31 import java.awt.event.ActionListener;
32 import java.awt.event.WindowAdapter;
33 import java.awt.event.WindowEvent;
34 import java.awt.event.WindowListener;
35 import java.io.IOException;
36 import java.io.PipedInputStream;
37 import java.io.PipedOutputStream;
38 import java.io.PrintStream;
39
40 import javax.swing.JButton;
41 import javax.swing.JFrame;
42 import javax.swing.JScrollPane;
43 import javax.swing.JTextArea;
44
45 import org.apache.log4j.SimpleLayout;
46
47 /**
48  * Simple Jalview Java Console. Version 1 - allows viewing of console output
49  * after desktop is created. Acquired with thanks from RJHM's site
50  * http://www.comweb.nl/java/Console/Console.html A simple Java Console for your
51  * application (Swing version) Requires Java 1.1.5 or higher Disclaimer the use
52  * of this source is at your own risk. Permision to use and distribute into your
53  * own applications RJHM van den Bergh , rvdb@comweb.nl
54  */
55
56 public class Console extends WindowAdapter implements WindowListener,
57         ActionListener, Runnable
58 {
59   private JFrame frame;
60
61   private JTextArea textArea;
62
63   /*
64    * unused - tally and limit for lines in console window int lines = 0;
65    * 
66    * int lim = 1000;
67    */
68   int byteslim = 102400, bytescut = 76800; // 100k and 75k cut point.
69
70   private Thread reader, reader2, textAppender;
71
72   private boolean quit;
73
74   private final PrintStream stdout = System.out, stderr = System.err;
75
76   private PipedInputStream pin = new PipedInputStream();
77
78   private PipedInputStream pin2 = new PipedInputStream();
79
80   private StringBuffer displayPipe = new StringBuffer();
81
82   Thread errorThrower; // just for testing (Throws an Exception at this Console
83
84   // are we attached to some parent Desktop
85   Desktop parent = null;
86
87   public Console()
88   {
89     // create all components and add them
90     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
91     frame = initFrame("Java Console", screenSize.width / 2,
92             screenSize.height / 2, -1, -1);
93     initConsole(true);
94   }
95
96   private void initConsole(boolean visible)
97   {
98     initConsole(visible, true);
99   }
100
101   /**
102    * 
103    * @param visible
104    *          - open the window
105    * @param redirect
106    *          - redirect std*
107    */
108   private void initConsole(boolean visible, boolean redirect)
109   {
110     // CutAndPasteTransfer cpt = new CutAndPasteTransfer();
111     // textArea = cpt.getTextArea();
112     textArea = new JTextArea();
113     textArea.setEditable(false);
114     JButton button = new JButton(MessageManager.getString("action.clear"));
115
116     // frame = cpt;
117     frame.getContentPane().setLayout(new BorderLayout());
118     frame.getContentPane().add(new JScrollPane(textArea),
119             BorderLayout.CENTER);
120     frame.getContentPane().add(button, BorderLayout.SOUTH);
121     frame.setVisible(visible);
122     updateConsole = visible;
123     frame.addWindowListener(this);
124     button.addActionListener(this);
125     if (redirect)
126     {
127       redirectStreams();
128     }
129     else
130     {
131       unredirectStreams();
132     }
133     quit = false; // signals the Threads that they should exit
134
135     // Starting two seperate threads to read from the PipedInputStreams
136     //
137     reader = new Thread(this);
138     reader.setDaemon(true);
139     reader.start();
140     //
141     reader2 = new Thread(this);
142     reader2.setDaemon(true);
143     reader2.start();
144     // and a thread to append text to the textarea
145     textAppender = new Thread(this);
146     textAppender.setDaemon(true);
147     textAppender.start();
148   }
149
150   PipedOutputStream pout = null, perr = null;
151
152   public void redirectStreams()
153   {
154     if (pout == null)
155     {
156       try
157       {
158         pout = new PipedOutputStream(this.pin);
159         System.setOut(new PrintStream(pout, true));
160       } catch (java.io.IOException io)
161       {
162         textArea.append("Couldn't redirect STDOUT to this console\n"
163                 + io.getMessage());
164         io.printStackTrace(stderr);
165       } catch (SecurityException se)
166       {
167         textArea.append("Couldn't redirect STDOUT to this console\n"
168                 + se.getMessage());
169         se.printStackTrace(stderr);
170       }
171
172       try
173       {
174         perr = new PipedOutputStream(this.pin2);
175         System.setErr(new PrintStream(perr, true));
176       } catch (java.io.IOException io)
177       {
178         textArea.append("Couldn't redirect STDERR to this console\n"
179                 + io.getMessage());
180         io.printStackTrace(stderr);
181       } catch (SecurityException se)
182       {
183         textArea.append("Couldn't redirect STDERR to this console\n"
184                 + se.getMessage());
185         se.printStackTrace(stderr);
186       }
187     }
188   }
189
190   public void unredirectStreams()
191   {
192     if (pout != null)
193     {
194       try
195       {
196         System.setOut(stdout);
197         pout.flush();
198         pout.close();
199         pin = new PipedInputStream();
200         pout = null;
201       } catch (java.io.IOException io)
202       {
203         textArea.append("Couldn't unredirect STDOUT to this console\n"
204                 + io.getMessage());
205         io.printStackTrace(stderr);
206       } catch (SecurityException se)
207       {
208         textArea.append("Couldn't unredirect STDOUT to this console\n"
209                 + se.getMessage());
210         se.printStackTrace(stderr);
211       }
212
213       try
214       {
215         System.setErr(stderr);
216         perr.flush();
217         perr.close();
218         pin2 = new PipedInputStream();
219         perr = null;
220       } catch (java.io.IOException io)
221       {
222         textArea.append("Couldn't unredirect STDERR to this console\n"
223                 + io.getMessage());
224         io.printStackTrace(stderr);
225       } catch (SecurityException se)
226       {
227         textArea.append("Couldn't unredirect STDERR to this console\n"
228                 + se.getMessage());
229         se.printStackTrace(stderr);
230       }
231     }
232   }
233
234   public void test()
235   {
236     // testing part
237     // you may omit this part for your application
238     //
239
240     System.out.println("Hello World 2");
241     System.out.println("All fonts available to Graphic2D:\n");
242     GraphicsEnvironment ge = GraphicsEnvironment
243             .getLocalGraphicsEnvironment();
244     String[] fontNames = ge.getAvailableFontFamilyNames();
245     for (int n = 0; n < fontNames.length; n++)
246       System.out.println(fontNames[n]);
247     // Testing part: simple an error thrown anywhere in this JVM will be printed
248     // on the Console
249     // We do it with a seperate Thread becasue we don't wan't to break a Thread
250     // used by the Console.
251     System.out.println("\nLets throw an error on this console");
252     errorThrower = new Thread(this);
253     errorThrower.setDaemon(true);
254     errorThrower.start();
255   }
256
257   private JFrame initFrame(String string, int i, int j, int x, int y)
258   {
259     JFrame frame = new JFrame(string);
260     frame.setName(string);
261     if (x == -1)
262       x = (int) (i / 2);
263     if (y == -1)
264       y = (int) (j / 2);
265     frame.setBounds(x, y, i, j);
266     return frame;
267   }
268
269   /**
270    * attach a console to the desktop - the desktop will open it if requested.
271    * 
272    * @param desktop
273    */
274   public Console(Desktop desktop)
275   {
276     this(desktop, true);
277   }
278
279   /**
280    * attach a console to the desktop - the desktop will open it if requested.
281    * 
282    * @param desktop
283    * @param showjconsole
284    *          - if true, then redirect stdout immediately
285    */
286   public Console(Desktop desktop, boolean showjconsole)
287   {
288     parent = desktop;
289     // window name - get x,y,width, height possibly scaled
290     Rectangle bounds = desktop.getLastKnownDimensions("JAVA_CONSOLE_");
291     if (bounds == null)
292     {
293       frame = initFrame("Jalview Java Console", desktop.getWidth() / 2,
294               desktop.getHeight() / 4, desktop.getX(), desktop.getY());
295     }
296     else
297     {
298       frame = initFrame("Jalview Java Console", bounds.width,
299               bounds.height, bounds.x, bounds.y);
300     }
301     // desktop.add(frame);
302     initConsole(false);
303     JalviewAppender jappender = new JalviewAppender();
304     jappender.setLayout(new SimpleLayout());
305     JalviewAppender.setTextArea(textArea);
306     org.apache.log4j.Logger.getRootLogger().addAppender(jappender);
307   }
308
309   public synchronized void stopConsole()
310   {
311     quit = true;
312     this.notifyAll();
313     /*
314      * reader.notify(); reader2.notify(); if (errorThrower!=null)
315      * errorThrower.notify(); // stop all threads if (textAppender!=null)
316      * textAppender.notify();
317      */
318     if (pout != null)
319     {
320       try
321       {
322         reader.join(10);
323         pin.close();
324       } catch (Exception e)
325       {
326       }
327       try
328       {
329         reader2.join(10);
330         pin2.close();
331       } catch (Exception e)
332       {
333       }
334       try
335       {
336         textAppender.join(10);
337       } catch (Exception e)
338       {
339       }
340     }
341     if (!frame.isVisible())
342     {
343       frame.dispose();
344     }
345     // System.exit(0);
346   }
347
348   public synchronized void windowClosed(WindowEvent evt)
349   {
350     frame.setVisible(false);
351     closeConsoleGui();
352   }
353
354   private void closeConsoleGui()
355   {
356     updateConsole = false;
357     if (parent == null)
358     {
359
360       stopConsole();
361     }
362     else
363     {
364       parent.showConsole(false);
365     }
366   }
367
368   public synchronized void windowClosing(WindowEvent evt)
369   {
370     frame.setVisible(false); // default behaviour of JFrame
371     closeConsoleGui();
372
373     // frame.dispose();
374   }
375
376   public synchronized void actionPerformed(ActionEvent evt)
377   {
378     trimBuffer(true);
379     // textArea.setText("");
380   }
381
382   public synchronized void run()
383   {
384     try
385     {
386       while (Thread.currentThread() == reader)
387       {
388         if (pin == null || pin.available() == 0)
389         {
390           try
391           {
392             this.wait(100);
393             if (pin.available() == 0)
394             {
395               trimBuffer(false);
396             }
397           } catch (InterruptedException ie)
398           {
399           }
400         }
401
402         while (pin.available() != 0)
403         {
404           String input = this.readLine(pin);
405           stdout.print(input);
406           long time = System.nanoTime();
407           appendToTextArea(input);
408           // stderr.println("Time taken to stdout append:\t"
409           // + (System.nanoTime() - time) + " ns");
410           // lines++;
411         }
412         if (quit)
413           return;
414       }
415
416       while (Thread.currentThread() == reader2)
417       {
418         if (pin2.available() == 0)
419         {
420           try
421           {
422             this.wait(100);
423             if (pin2.available() == 0)
424             {
425               trimBuffer(false);
426             }
427           } catch (InterruptedException ie)
428           {
429           }
430         }
431         while (pin2.available() != 0)
432         {
433           String input = this.readLine(pin2);
434           stderr.print(input);
435           long time = System.nanoTime();
436           appendToTextArea(input);
437           // stderr.println("Time taken to stderr append:\t"
438           // + (System.nanoTime() - time) + " ns");
439           // lines++;
440         }
441         if (quit)
442           return;
443       }
444       while (Thread.currentThread() == textAppender)
445       {
446         if (updateConsole)
447         {
448           // check string buffer - if greater than console, clear console and
449           // replace with last segment of content, otherwise, append all to
450           // content.
451           long count;
452           while (displayPipe.length() > 0)
453           {
454             count = 0;
455             StringBuffer tmp = new StringBuffer(), replace;
456             synchronized (displayPipe)
457             {
458               replace = displayPipe;
459               displayPipe = tmp;
460             }
461             // simply append whole buffer
462             textArea.append(replace.toString());
463             count += replace.length();
464             if (count > byteslim)
465             {
466               trimBuffer(false);
467             }
468           }
469           if (displayPipe.length() == 0)
470           {
471             try
472             {
473               this.wait(100);
474               if (displayPipe.length() == 0)
475               {
476                 trimBuffer(false);
477               }
478             } catch (InterruptedException e)
479             {
480             }
481             ;
482           }
483         }
484         else
485         {
486           try
487           {
488             this.wait(100);
489           } catch (InterruptedException e)
490           {
491
492           }
493         }
494         if (quit)
495         {
496           return;
497         }
498
499       }
500     } catch (Exception e)
501     {
502       textArea.append("\nConsole reports an Internal error.");
503       textArea.append("The error is: " + e.getMessage());
504       // Need to uncomment this to ensure that line tally is synched.
505       // lines += 2;
506       stderr.println("Console reports an Internal error.\nThe error is: "
507               + e);
508     }
509
510     // just for testing (Throw a Nullpointer after 1 second)
511     if (Thread.currentThread() == errorThrower)
512     {
513       try
514       {
515         this.wait(1000);
516       } catch (InterruptedException ie)
517       {
518       }
519       throw new NullPointerException(
520               MessageManager.getString("exception.application_test_npe"));
521     }
522   }
523
524   private void appendToTextArea(final String input)
525   {
526     if (updateConsole == false)
527     {
528       // do nothing;
529       return;
530     }
531     long time = System.nanoTime();
532     javax.swing.SwingUtilities.invokeLater(new Runnable()
533     {
534       public void run()
535       {
536         displayPipe.append(input); // change to stringBuffer
537         // displayPipe.flush();
538
539       }
540     });
541     // stderr.println("Time taken to Spawnappend:\t" + (System.nanoTime() -
542     // time)
543     // + " ns");
544   }
545
546   private String header = null;
547
548   private boolean updateConsole = false;
549
550   private synchronized void trimBuffer(boolean clear)
551   {
552     if (header == null && textArea.getLineCount() > 5)
553     {
554       try
555       {
556         header = textArea.getText(0, textArea.getLineStartOffset(5))
557                 + "\nTruncated...\n";
558       } catch (Exception e)
559       {
560         e.printStackTrace();
561       }
562     }
563     // trim the buffer
564     int tlength = textArea.getDocument().getLength();
565     if (header != null)
566     {
567       if (clear || (tlength > byteslim))
568       {
569         try
570         {
571           if (!clear)
572           {
573             long time = System.nanoTime();
574             textArea.replaceRange(header, 0, tlength - bytescut);
575             // stderr.println("Time taken to cut:\t"
576             // + (System.nanoTime() - time) + " ns");
577           }
578           else
579           {
580             textArea.setText(header);
581           }
582         } catch (Exception e)
583         {
584           e.printStackTrace();
585         }
586         // lines = textArea.getLineCount();
587       }
588     }
589
590   }
591
592   public synchronized String readLine(PipedInputStream in)
593           throws IOException
594   {
595     String input = "";
596     int lp = -1;
597     do
598     {
599       int available = in.available();
600       if (available == 0)
601         break;
602       byte b[] = new byte[available];
603       in.read(b);
604       input = input + new String(b, 0, b.length);
605       // counts lines - we don't do this for speed.
606       // while ((lp = input.indexOf("\n", lp + 1)) > -1)
607       // {
608       // lines++;
609       // }
610     } while (!input.endsWith("\n") && !input.endsWith("\r\n") && !quit);
611     return input;
612   }
613
614   public static void main(String[] arg)
615   {
616     new Console().test(); // create console with not reference
617
618   }
619
620   public void setVisible(boolean selected)
621   {
622     frame.setVisible(selected);
623     if (selected == true)
624     {
625       redirectStreams();
626       updateConsole = true;
627       frame.toFront();
628     }
629     else
630     {
631       unredirectStreams();
632       updateConsole = false;
633     }
634   }
635
636   public Rectangle getBounds()
637   {
638     if (frame != null)
639     {
640       return frame.getBounds();
641     }
642     return null;
643   }
644
645   /**
646    * set the banner that appears at the top of the console output
647    * 
648    * @param string
649    */
650   public void setHeader(String string)
651   {
652     header = string;
653     if (header.charAt(header.length() - 1) != '\n')
654     {
655       header += "\n";
656     }
657     textArea.insert(header, 0);
658   }
659
660   /**
661    * get the banner
662    * 
663    * @return
664    */
665   public String getHeader()
666   {
667     return header;
668   }
669 }