Merge branch 'spotless_2' into JAL-1551_2_11_3_spotlett
[jalview.git] / src / jalview / util / AWTConsole.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.util;
22
23 //
24 // A simple Java Console for your application (Swing version)
25 // Requires Java 1.1.5 or higher
26 //
27 // Disclaimer the use of this source is at your own risk. 
28 //
29 // Permision to use and distribute into your own applications
30 //
31 // RJHM van den Bergh , rvdb@comweb.nl
32
33 import java.awt.BorderLayout;
34 import java.awt.Button;
35 import java.awt.Dimension;
36 import java.awt.Frame;
37 import java.awt.GraphicsEnvironment;
38 import java.awt.Panel;
39 import java.awt.TextArea;
40 import java.awt.Toolkit;
41 import java.awt.event.ActionEvent;
42 import java.awt.event.ActionListener;
43 import java.awt.event.WindowAdapter;
44 import java.awt.event.WindowEvent;
45 import java.awt.event.WindowListener;
46 import java.io.IOException;
47 import java.io.PipedInputStream;
48 import java.io.PipedOutputStream;
49 import java.io.PrintStream;
50
51 import jalview.bin.Jalview;
52
53 public class AWTConsole extends WindowAdapter
54         implements WindowListener, ActionListener, Runnable
55 {
56   private Frame frame;
57
58   private TextArea textArea;
59
60   private Thread reader;
61
62   private Thread reader2;
63
64   private boolean quit;
65
66   private final PipedInputStream pin = new PipedInputStream();
67
68   private final PipedInputStream pin2 = new PipedInputStream();
69
70   Thread errorThrower; // just for testing (Throws an Exception at this Console
71
72   public AWTConsole()
73   {
74     // create all components and add them
75     frame = new Frame("Java Console");
76     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
77     Dimension frameSize = new Dimension(screenSize.width / 2,
78             screenSize.height / 2);
79     int x = frameSize.width / 2;
80     int y = frameSize.height / 2;
81     frame.setBounds(x, y, frameSize.width, frameSize.height);
82
83     textArea = new TextArea();
84     textArea.setEditable(false);
85     Button button = new Button("clear");
86
87     Panel panel = new Panel();
88     panel.setLayout(new BorderLayout());
89     panel.add(textArea, BorderLayout.CENTER);
90     panel.add(button, BorderLayout.SOUTH);
91     frame.add(panel);
92
93     frame.setVisible(true);
94
95     frame.addWindowListener(this);
96     button.addActionListener(this);
97
98     try
99     {
100       PipedOutputStream pout = new PipedOutputStream(this.pin);
101       System.setOut(new PrintStream(pout, true));
102     } catch (java.io.IOException io)
103     {
104       textArea.append("Couldn't redirect STDOUT to this console\n"
105               + io.getMessage());
106     } catch (SecurityException se)
107     {
108       textArea.append("Couldn't redirect STDOUT to this console\n"
109               + se.getMessage());
110     }
111
112     try
113     {
114       PipedOutputStream pout2 = new PipedOutputStream(this.pin2);
115       System.setErr(new PrintStream(pout2, true));
116     } catch (java.io.IOException io)
117     {
118       textArea.append("Couldn't redirect STDERR to this console\n"
119               + io.getMessage());
120     } catch (SecurityException se)
121     {
122       textArea.append("Couldn't redirect STDERR to this console\n"
123               + se.getMessage());
124     }
125
126     quit = false; // signals the Threads that they should exit
127
128     // Starting two seperate threads to read from the PipedInputStreams
129     //
130     reader = new Thread(this);
131     reader.setDaemon(true);
132     reader.start();
133     //
134     reader2 = new Thread(this);
135     reader2.setDaemon(true);
136     reader2.start();
137
138     // testing part
139     // you may omit this part for your application
140     //
141     System.out.println("Hello World 2");
142     System.out.println("All fonts available to Graphic2D:\n");
143     GraphicsEnvironment ge = GraphicsEnvironment
144             .getLocalGraphicsEnvironment();
145     String[] fontNames = ge.getAvailableFontFamilyNames();
146     for (int n = 0; n < fontNames.length; n++)
147     {
148       System.out.println(fontNames[n]);
149     }
150     // Testing part: simple an error thrown anywhere in this JVM will be printed
151     // on the Console
152     // We do it with a seperate Thread becasue we don't wan't to break a Thread
153     // used by the Console.
154     System.out.println("\nLets throw an error on this console");
155     errorThrower = new Thread(this);
156     errorThrower.setDaemon(true);
157     errorThrower.start();
158   }
159
160   @Override
161   public synchronized void windowClosed(WindowEvent evt)
162   {
163     quit = true;
164     this.notifyAll(); // stop all threads
165     try
166     {
167       reader.join(1000);
168       pin.close();
169     } catch (Exception e)
170     {
171     }
172     try
173     {
174       reader2.join(1000);
175       pin2.close();
176     } catch (Exception e)
177     {
178     }
179     Jalview.exit("Window closing. Bye!", 0);
180   }
181
182   @Override
183   public synchronized void windowClosing(WindowEvent evt)
184   {
185     frame.setVisible(false); // default behaviour of JFrame
186     frame.dispose();
187   }
188
189   @Override
190   public synchronized void actionPerformed(ActionEvent evt)
191   {
192     textArea.setText("");
193   }
194
195   @Override
196   public synchronized void run()
197   {
198     try
199     {
200       while (Thread.currentThread() == reader)
201       {
202         try
203         {
204           this.wait(100);
205         } catch (InterruptedException ie)
206         {
207         }
208         if (pin.available() != 0)
209         {
210           String input = this.readLine(pin);
211           textArea.append(input);
212         }
213         if (quit)
214         {
215           return;
216         }
217       }
218
219       while (Thread.currentThread() == reader2)
220       {
221         try
222         {
223           this.wait(100);
224         } catch (InterruptedException ie)
225         {
226         }
227         if (pin2.available() != 0)
228         {
229           String input = this.readLine(pin2);
230           textArea.append(input);
231         }
232         if (quit)
233         {
234           return;
235         }
236       }
237     } catch (Exception e)
238     {
239       textArea.append("\nConsole reports an Internal error.");
240       textArea.append("The error is: " + e);
241     }
242
243     // just for testing (Throw a Nullpointer after 1 second)
244     if (Thread.currentThread() == errorThrower)
245     {
246       try
247       {
248         this.wait(1000);
249       } catch (InterruptedException ie)
250       {
251       }
252       throw new NullPointerException(
253               MessageManager.getString("exception.application_test_npe"));
254     }
255
256   }
257
258   public synchronized String readLine(PipedInputStream in)
259           throws IOException
260   {
261     String input = "";
262     do
263     {
264       int available = in.available();
265       if (available == 0)
266       {
267         break;
268       }
269       byte b[] = new byte[available];
270       in.read(b);
271       input = input + new String(b, 0, b.length);
272     } while (!input.endsWith("\n") && !input.endsWith("\r\n") && !quit);
273     return input;
274   }
275
276   /**
277    * 
278    * @param arg
279    * @j2sIgnore
280    */
281   public static void main(String[] arg)
282   {
283     new AWTConsole(); // create console with not reference
284   }
285 }