|
GUILoginConsole |
|
1 // joi/10/juno/GUILoginConsole.java
2 //
3 //
4 // Copyright 2003 Bill Campbell and Ethan Bolker
5
6 import javax.swing.*;
7 import javax.swing.event.*;
8 import java.awt.*;
9 import java.awt.event.*;
10
11 /**
12 * The graphical user interface to Juno.
13 */
14
15 public class GUILoginConsole extends JFrame
16 implements OutputInterface
17 {
18 private static final int FIELDWIDTH = 30;
19 private static final int FIELDHEIGHT = 5;
20
21 private final Juno junoSystem;
22 private WindowCloser closeMe; // to shut down Juno
23
24 private String title; // title for the windows
25
26 // The interpreter interprets one-line commands.
27 private InterpreterInterface interpreter;
28 private boolean echoInput;
29
30 // All output goes to messages.
31 private JTextArea messages;
32
33 /**
34 * Construct a GUI console for Juno.
35 *
36 * @param title the title for this window.
37 * @param junoSystem the Juno system for which this is a GUI
38 * @param interpreter the object to which to send user input.
39 * @param echoInput true when input echoes to this console.
40 */
41
42 public GUILoginConsole( String title, Juno junoSystem,
43 InterpreterInterface interpreter,
44 boolean echoInput)
45 {
46 super( title );
47 this.title = title;
48 this.junoSystem = junoSystem;
49 this.interpreter = interpreter;
50 this.echoInput = echoInput;
51 this.closeMe = new WindowCloser( junoSystem );
52
53 // Set up the look and feel;
54 // Everthing is placed on a panel (using BorderLayout)
55
56 JPanel panel = new JPanel();
57 panel.setLayout( new BorderLayout() );
58
59 // First a tabbed pane, with two tabs:
60 // one for login, one for registration
61
62 JTabbedPane tabs = new JTabbedPane();
63 tabs.addTab( "Login" , null,
64 new LoginPane( interpreter, echoInput, closeMe ) );
65 tabs.addTab( "Register", null,
66 new RegisterPane( interpreter, echoInput ) );
67 tabs.setSelectedIndex( 0 ); // Login selected by default
68 panel.add( tabs, BorderLayout.NORTH );
69
70 // and the output messages area.
71 panel.add( new JLabel( "Messages:" ), BorderLayout.CENTER );
72 messages = new JTextArea( FIELDHEIGHT, FIELDWIDTH );
73 panel.add( messages, BorderLayout.SOUTH );
74
75 // Add the panel to this JFrame
76 this.getContentPane().add( panel );
77
78 // Closing this window
79 this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
80 this.addWindowListener( closeMe );
81
82 // Size and display this JFrame
83 pack();
84 show();
85 }
86
87 // Implementing the OutputInterface. Everything goes to the
88 // single message area.
89
90 /**
91 * Write a String followed by a newline
92 * to message area.
93 *
94 * @param str - the string to write
95 */
96
97 public void println(String str )
98 {
99 messages.append( str + "\n" );
100 }
101
102 /**
103 * Write a String followed by a newline
104 * to message area.
105 *
106 * @param str - the String to write
107 */
108
109 public void errPrintln(String str )
110 {
111 println( str );
112 }
113
114 /**
115 * Query what kind of console this is.
116 *
117 * @return true if and only if echoing input.
118 */
119
120 public boolean isEchoInput()
121 {
122 return echoInput;
123 }
124
125 /**
126 * Query what kind of console this is.
127 *
128 * @return true if and only if GUI
129 */
130
131 public boolean isGUI()
132 {
133 return true;
134 }
135
136 /**
137 * Query what kind of console this is.
138 *
139 * @return true if and only if remote
140 */
141
142 public boolean isRemote()
143 {
144 return false;
145 }
146
147 // The Login pane is specified in a private inner class,
148 // visible only here.
149
150 private class LoginPane extends JPanel
151 {
152 // The login pane has two text fields and two buttons.
153 private JTextField nameField;
154 private JTextField passwordField;
155
156 private JButton ok;
157 private JButton exit;
158
159 private WindowCloser closeMe; // to shut down Juno
160 // Construct the login pane and set up its listeners.
161
162 public LoginPane( InterpreterInterface interpreter,
163 boolean echoInput, WindowCloser closeMe )
164 {
165 super();
166 this.closeMe = closeMe;
167
168 // Set up the look and feel.
169 // Everything will go into a vertical Box, a container
170 // whose contents are laid out using BoxLayout
171
172 Box box = Box.createVerticalBox();
173
174 // First a panel, containing the two text fields
175
176 JPanel p = new JPanel();
177 p.setLayout( new GridLayout( 4 , 1 ) );
178
179 p.add( new JLabel( "Login:" ) );
180 nameField = new JTextField( FIELDWIDTH );
181 p.add( nameField );
182
183 p.add( new JLabel( "Password:" ) );
184 passwordField = new JPasswordField( FIELDWIDTH );
185 p.add( passwordField );
186 box.add( p );
187 box.add( Box.createVerticalStrut( 15 ) );
188
189 // Then a horizontal Box containing the two buttons
190
191 Box row = Box.createHorizontalBox();
192 row.add( Box.createGlue() );
193
194 ok = new JButton( "OK" );
195 row.add( ok );
196 row.add( Box.createGlue() );
197
198 exit = new JButton( "Exit" );
199 row.add( exit );
200 row.add( Box.createGlue() );
201 box.add( row );
202 box.add( Box.createVerticalStrut( 15 ) );
203
204 this.setLayout( new BorderLayout() );
205 this.add( box, BorderLayout.CENTER );
206
207 // Set up the listeners (the semantics)
208
209 ok.addActionListener( new LoginProcessor() );
210 exit.addActionListener( closeMe ); // shuts down Juno
211 }
212
213 // An inner inner class for the semantics
214 // when the user clicks OK.
215
216 private class LoginProcessor implements ActionListener
217 {
218 public void actionPerformed(ActionEvent e)
219 {
220 String str = nameField.getText() + " " +
221 passwordField.getText();
222 nameField.setText("");
223 passwordField.setText("");
224 messages.setText(str+'\n'); // for debugging
225 interpreter.interpret( str );
226 }
227 }
228 }
229
230 // The Register pane is specified in a private inner class,
231 // visible only here.
232
233 private class RegisterPane extends JPanel
234 {
235 // The register pane has four textfields and two buttons.
236 private JTextField chosenName;
237 private JTextField fullName;
238 private JTextField password1;
239 private JTextField password2;
240
241 private JButton register;
242 private JButton clear;
243
244 public RegisterPane( InterpreterInterface interpreter,
245 boolean echoInput)
246 {
247 super();
248
249 // Define the look and feel
250 // Everything goes into a vertical Box
251 Box box = Box.createVerticalBox();
252
253 // First a panel containing the text fields
254
255 JPanel p = new JPanel();
256 p.setLayout( new GridLayout( 0 , 1 ) );
257
258 p.add( new JLabel( "Choose login name:" ) );
259 chosenName = new JTextField( FIELDWIDTH );
260 p.add( chosenName );
261
262 p.add( new JLabel( "Give full name:" ) );
263 fullName = new JTextField( FIELDWIDTH );
264 p.add( fullName );
265
266 p.add( new JLabel( "Choose password:" ) );
267 password1 = new JPasswordField( FIELDWIDTH );
268 p.add( password1 );
269
270 p.add( new JLabel( "Retype password:" ) );
271 password2 = new JPasswordField( FIELDWIDTH );
272 p.add( password2 );
273
274 box.add( p );
275 box.add( Box.createVerticalStrut( 15 ) );
276
277 // Then a horizontal Box containing the buttons
278
279 Box row = Box.createHorizontalBox();
280 row.add( Box.createGlue() );
281 register = new JButton( "Register" );
282 row.add( register );
283 row.add( Box.createGlue() );
284 clear = new JButton( "Clear" );
285 row.add( clear );
286 row.add( Box.createGlue() );
287 box.add( row );
288 box.add( Box.createVerticalStrut( 15 ) );
289
290 this.setLayout( new BorderLayout() );
291 this.add( box, BorderLayout.CENTER );
292
293 // Set up the listeners (the semantics)
294
295 register.addActionListener( new Registration() );
296 clear.addActionListener( new Cleanser() );
297 }
298
299 // An inner inner class for the semantics when the user
300 // clicks Register.
301
302 private class Registration implements ActionListener
303 {
304 public void actionPerformed(ActionEvent e)
305 {
306 if ( password1.getText().trim().equals(
307 password2.getText().trim() ) ) {
308 String str = "register " +
309 chosenName.getText() + " " +
310 password1.getText() + " " +
311 fullName.getText() ;
312 chosenName.setText("");
313 fullName.setText("");
314 messages.setText(str+'\n'); // for debugging
315 interpreter.interpret(str);
316 }
317 else {
318 messages.setText(
319 "Sorry, passwords don't match.\n" );
320 }
321 password1.setText("");
322 password2.setText("");
323 }
324 }
325
326 // An inner inner class for the semantics when the user
327 // clicks Clear.
328
329 private class Cleanser implements ActionListener {
330 public void actionPerformed(ActionEvent e) {
331 chosenName.setText("");
332 fullName.setText("");
333 password1.setText("");
334 password2.setText("");
335 }
336 }
337 }
338
339 // A WindowCloser instance handles close events generated
340 // by the underlying window system with its windowClosing
341 // method, and close events from buttons or other user
342 // components with its actionPerformed method.
343 //
344 // The action is to shut down Juno.
345
346 private static class WindowCloser extends WindowAdapter
347 implements ActionListener
348 {
349 Juno system;
350
351 public WindowCloser( Juno system )
352 {
353 this.system = system;
354 }
355
356 public void windowClosing (WindowEvent e)
357 {
358 this.actionPerformed( null );
359 }
360
361 public void actionPerformed(ActionEvent e)
362 {
363 if (system != null) {
364 system.shutDown();
365 }
366 System.exit(0);
367 }
368 }
369
370 /**
371 * main() in GUILoginConsole class for
372 * unit testing during development.
373 */
374
375 public static void main( String[] args )
376 {
377 new GUILoginConsole( "GUItest", null, null, true ).show();
378 }
379 }
380
381
|
GUILoginConsole |
|