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