|
1
19 package org.netbeans.bluej.ant.task;
20
21 import java.io.BufferedReader  ;
22 import java.io.IOException ;
23 import java.io.InputStream ;
24 import java.io.InputStreamReader ;
25 import java.io.OutputStream ;
26 import java.io.OutputStreamWriter ;
27 import java.io.PrintWriter ;
28 import java.io.Reader ;
29 import java.util.Iterator ;
30 import java.util.Map ;
31 import java.util.WeakHashMap ;
32 import org.apache.tools.ant.BuildException;
33 import org.apache.tools.ant.Task;
34 import org.apache.tools.ant.taskdefs.ExecuteStreamHandler;
35 import org.apache.tools.ant.taskdefs.Java;
36 import org.apache.tools.ant.taskdefs.Redirector;
37 import org.openide.util.RequestProcessor;
38 import org.openide.windows.IOProvider;
39 import org.openide.windows.InputOutput;
40 import org.openide.windows.OutputWriter;
41
42
46 public class BlueJava extends Java {
47
48 public BlueJava() {
49 redirector = new MyRedirector(this);
50 }
51
52
53 private class MyRedirector extends Redirector {
54 public MyRedirector(Task task) {
55 super(task);
56 }
57 public ExecuteStreamHandler createHandler() throws BuildException {
58 createStreams();
59 return new NbOutputStreamHandler(getProject().getName());
60 }
61
62 }
63
64 private static final RequestProcessor PROCESSOR = new RequestProcessor("Netbeans-Bluej Run IO redirection", 5);
65
71 private static final Map freeTabs = new WeakHashMap ();
72
73
74 private static class NbOutputStreamHandler implements ExecuteStreamHandler {
75 private InputOutput io;
76 private RequestProcessor.Task outTask;
77 private RequestProcessor.Task errTask;
78 private RequestProcessor.Task inTask;
79 private Input input;
80 private String displayName;
81 public NbOutputStreamHandler(String name) {
82 displayName = "Run " + name;
83 synchronized (freeTabs) {
86 Iterator it = freeTabs.entrySet().iterator();
87 while (it.hasNext()) {
88 Map.Entry entry = (Map.Entry )it.next();
89 InputOutput free = (InputOutput)entry.getKey();
90 String freeName = (String )entry.getValue();
91 if (io == null && freeName.equals(displayName)) {
92 io = free;
94 try {
95 io.getOut().reset();
96 io.getErr().reset();
97 } catch (IOException ex) {
98 ex.printStackTrace();
99 }
100 } else {
102 free.closeInputOutput();
104 }
105 }
106 freeTabs.clear();
107 }
108 if (io == null) {
110 io = IOProvider.getDefault().getIO(displayName, true);
111 }
112
113 }
114 public void stop() {
115 if (input != null) {
116 input.closeReader();
117 }
118 if (inTask != null) {
119 inTask.waitFinished();
120 }
121 if (errTask != null) {
122 errTask.waitFinished();
123 }
124 if (outTask != null) {
125 outTask.waitFinished();
126 }
127 synchronized (freeTabs) {
128 freeTabs.put(io, displayName);
129 }
130 }
131
132 public void start() throws IOException {
133 io.select();
134 }
135
136 public void setProcessOutputStream(InputStream inputStream) throws IOException {
137 Output out = new Output(inputStream, io.getOut());
138 outTask = PROCESSOR.post(out);
139 }
140
141 public void setProcessErrorStream(InputStream inputStream) throws IOException {
142 Output err = new Output(inputStream, io.getErr());
143 errTask = PROCESSOR.post(err);
144 }
145
146 public void setProcessInputStream(OutputStream outputStream) throws IOException {
147 input = new Input(io.getIn(), outputStream);
148 inTask = PROCESSOR.post(input);
149 }
150
151 }
152
153 private static class Output implements Runnable {
154 private InputStreamReader str;
155 private OutputWriter writer;
156 public Output(InputStream instream, OutputWriter out) {
157 str = new InputStreamReader (instream);
158 writer = out;
159 }
160
161 public void run() {
162 try {
163 int chr = str.read();
164 while (chr != -1) {
165 if (chr == (int)'\n') {
166 writer.println();
167 } else {
168 writer.write(chr);
169 }
170 chr = str.read();
171 }
172 } catch (IOException ex) {
173 ex.printStackTrace();
174 } finally {
175 try {
176 str.close();
177 } catch (IOException ex) {
178 ex.printStackTrace();
179 }
180 closeWriter();
181 }
182 }
183
184 public void closeWriter() {
185 writer.close();
186 }
187 }
188
189 private static class Input implements Runnable {
190 private Reader ioReader;
191 private BufferedReader str;
192 private PrintWriter writer;
193 public Input(Reader instream, OutputStream out) {
194 ioReader = instream;
195 str = new BufferedReader (instream);
196 writer = new PrintWriter (new OutputStreamWriter (out));
197 }
198
199 public void closeReader() {
200 try {
201 ioReader.close();
203 str.close();
204 writer.close();
205 } catch (IOException exc) {
206 exc.printStackTrace();
207 }
208 }
209
210 public void run() {
211 try {
212 String line = str.readLine();
213 while (line != null) {
214 if (!writer.checkError()) {
215 writer.println(line);
216 writer.flush();
217 } else {
218 break;
219 }
220 line = str.readLine();
221 }
222 } catch (IOException ex) {
223 ex.printStackTrace();
224 } finally {
225 writer.close();
226 }
227 }
228
229 }
230
231 }
232
233 |
Popular Tags |
Java API By Example, From Geeks To Geeks.