001: /*
002: * Jacareto Copyright (c) 2002-2005
003: * Applied Computer Science Research Group, Darmstadt University of
004: * Technology, Institute of Mathematics & Computer Science,
005: * Ludwigsburg University of Education, and Computer Based
006: * Learning Research Group, Aachen University. All rights reserved.
007: *
008: * Jacareto is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU General Public
010: * License as published by the Free Software Foundation; either
011: * version 2 of the License, or (at your option) any later version.
012: *
013: * Jacareto is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016: * General Public License for more details.
017: *
018: * You should have received a copy of the GNU General Public
019: * License along with Jacareto; if not, write to the Free
020: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
021: *
022: */
023:
024: package jacareto.cleverphl.gui;
025:
026: import jacareto.cleverphl.CleverPHL;
027: import jacareto.cleverphl.session.Session;
028: import jacareto.editor.AppletStarterEditor;
029: import jacareto.editor.ApplicationStarterEditor;
030: import jacareto.editor.Editor;
031: import jacareto.starter.AppletStarter;
032: import jacareto.starter.ApplicationStarter;
033: import jacareto.starter.Starter;
034: import jacareto.system.Environment;
035: import jacareto.system.Language;
036: import jacareto.toolkit.swing.ExtensionFileFilter;
037:
038: import java.awt.BorderLayout;
039: import java.awt.Color;
040: import java.awt.GridBagConstraints;
041: import java.awt.GridBagLayout;
042: import java.awt.Insets;
043: import java.awt.Point;
044: import java.awt.event.ActionEvent;
045: import java.awt.event.ActionListener;
046: import java.awt.event.MouseEvent;
047: import java.awt.event.MouseListener;
048:
049: import javax.swing.DefaultListSelectionModel;
050: import javax.swing.JButton;
051: import javax.swing.JDialog;
052: import javax.swing.JFileChooser;
053: import javax.swing.JList;
054: import javax.swing.JPanel;
055: import javax.swing.JScrollPane;
056: import javax.swing.border.EmptyBorder;
057: import javax.swing.border.LineBorder;
058: import javax.swing.border.TitledBorder;
059:
060: /**
061: * Dialog for starting programs.
062: *
063: * @author <a href="mailto:cspannagel@web.de">Christian Spannagel</a>
064: * @version 1.01
065: */
066: public class StartProgramDialog extends JDialog implements
067: ActionListener {
068: /** The CleverPHL instance. */
069: private CleverPHL cleverPHL;
070:
071: /** The environment. */
072: private Environment env;
073:
074: /** The list of starters. */
075: private JList list;
076:
077: /** The starter which has been selected. */
078: private Starter selectedStarter;
079:
080: /** The ok button. */
081: private JButton okButton;
082:
083: /** The cancel button. */
084: private JButton cancelButton;
085:
086: /** The button for loading a starters list. */
087: private JButton loadButton;
088:
089: /** The button for storing the starters list. */
090: private JButton saveButton;
091:
092: /** The button for clearing the list. */
093: private JButton clearButton;
094:
095: /** The button for editing a starter. */
096: private JButton editButton;
097:
098: /** The button for removing a starter. */
099: private JButton removeButton;
100:
101: /** The button for creating a new application starter. */
102: private JButton applicationStarterButton;
103:
104: /** The button for creating a new applet starter. */
105: private JButton appletStarterButton;
106:
107: /**
108: * Creates a new dialog (visible).
109: *
110: * @param cleverPHL the CleverPHL instance
111: */
112: public StartProgramDialog(CleverPHL cleverPHL) {
113: super (cleverPHL.getMainFrame(), true);
114: this .cleverPHL = cleverPHL;
115: this .env = cleverPHL.getEnvironment();
116: selectedStarter = null;
117: setName(cleverPHL.getCustomization().getString(
118: "Components.JacaretoComponent", "JACARETO_COMPONENT"));
119:
120: Language language = env.getLanguage();
121: Session session = cleverPHL.getSessionList().getActual();
122:
123: setTitle(language
124: .getString("CleverPHL.StartProgramDialog.Title"));
125:
126: // The starter list
127: list = new JList(session.getStarterList());
128: list
129: .setSelectionMode(DefaultListSelectionModel.SINGLE_SELECTION);
130:
131: TitledBorder listBorder = new TitledBorder(new LineBorder(
132: Color.black), language
133: .getString("CleverPHL.StartProgramDialog.ListLabel"));
134:
135: //list.setFixedCellWidth ((int) listBorder.getMinimumSize(this).getWidth());
136: list.setFixedCellWidth(200);
137: list.setVisibleRowCount(10);
138: list.addMouseListener(new ListMouseListener(this ));
139:
140: JScrollPane listScrollPane = new JScrollPane(list);
141: listScrollPane.setBorder(listBorder);
142:
143: JPanel leftPanelWrapper = new JPanel();
144: leftPanelWrapper.setLayout(new BorderLayout());
145: leftPanelWrapper.setBorder(new EmptyBorder(5, 5, 5, 5));
146: leftPanelWrapper.add(listScrollPane, BorderLayout.NORTH);
147:
148: // The right button panel
149: JPanel rightButtonPanel = new JPanel();
150: rightButtonPanel.setLayout(new GridBagLayout());
151:
152: GridBagConstraints c = new GridBagConstraints();
153: c.gridx = 0;
154: c.gridy = 0;
155: c.insets = new Insets(5, 5, 5, 5);
156: c.anchor = GridBagConstraints.WEST;
157: c.fill = GridBagConstraints.NONE;
158: loadButton = new JButton(language
159: .getString("CleverPHL.StartProgramDialog.Load"));
160: loadButton.addActionListener(this );
161: rightButtonPanel.add(loadButton, c);
162: c.gridy = 1;
163: saveButton = new JButton(language
164: .getString("CleverPHL.StartProgramDialog.Save"));
165: saveButton.addActionListener(this );
166: rightButtonPanel.add(saveButton, c);
167: c.gridy = 2;
168: clearButton = new JButton(language
169: .getString("CleverPHL.StartProgramDialog.Clear"));
170: clearButton.addActionListener(this );
171: rightButtonPanel.add(clearButton, c);
172: c.gridy = 3;
173: editButton = new JButton(language
174: .getString("CleverPHL.StartProgramDialog.Edit"));
175: editButton.addActionListener(this );
176: rightButtonPanel.add(editButton, c);
177: c.gridy = 4;
178: removeButton = new JButton(language
179: .getString("CleverPHL.StartProgramDialog.Remove"));
180: removeButton.addActionListener(this );
181: rightButtonPanel.add(removeButton, c);
182: c.gridy = 5;
183: applicationStarterButton = new JButton(
184: language
185: .getString("CleverPHL.StartProgramDialog.NewApplicationStarter"));
186: applicationStarterButton.addActionListener(this );
187: rightButtonPanel.add(applicationStarterButton, c);
188: c.gridy = 6;
189: appletStarterButton = new JButton(
190: language
191: .getString("CleverPHL.StartProgramDialog.NewAppletStarter"));
192: appletStarterButton.addActionListener(this );
193: rightButtonPanel.add(appletStarterButton, c);
194:
195: rightButtonPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
196:
197: JPanel rightButtonPanelWrapper = new JPanel();
198: rightButtonPanelWrapper.setLayout(new BorderLayout());
199: rightButtonPanelWrapper.add(rightButtonPanel,
200: BorderLayout.NORTH);
201:
202: // The panel with the two buttons
203: JPanel buttonPanel = new JPanel();
204: okButton = new JButton(language.getString("General.Ok"));
205: okButton.addActionListener(this );
206: cancelButton = new JButton(language.getString("General.Cancel"));
207: cancelButton.addActionListener(this );
208: buttonPanel.add(okButton);
209: buttonPanel.add(cancelButton);
210: buttonPanel.setBorder(new EmptyBorder(10, 10, 10, 10));
211:
212: // Add all to the content pane
213: getContentPane().setLayout(new BorderLayout());
214: getContentPane().add(leftPanelWrapper, BorderLayout.CENTER);
215: getContentPane()
216: .add(rightButtonPanelWrapper, BorderLayout.EAST);
217: getContentPane().add(buttonPanel, BorderLayout.SOUTH);
218:
219: Point ownerLoc = cleverPHL.getMainFrame().getLocation();
220: setLocation(((int) ownerLoc.getX()) + 30, ((int) ownerLoc
221: .getY()) + 30);
222:
223: pack();
224: setResizable(false);
225: setVisible(true);
226: }
227:
228: /**
229: * Called when one of the two buttons has been pressed.
230: *
231: * @param e the action event
232: */
233: public void actionPerformed(ActionEvent e) {
234: Language language = cleverPHL.getLanguage();
235: Session session = cleverPHL.getSessionList().getActual();
236:
237: Object source = e.getSource();
238:
239: if (source == okButton) {
240: if (list.isSelectionEmpty()) {
241: new CleverPHLMsgDialog(
242: cleverPHL,
243: this ,
244: language.getString("General.Error"),
245: language
246: .getString("CleverPHL.StartProgramDialog.Error.NoSelectedStarter"),
247: language.getString("General.Ok"));
248: } else {
249: close();
250: }
251: } else if (source == cancelButton) {
252: dispose();
253: } else if (source == clearButton) {
254: CleverPHLConfirmDialog confirmDialog = new CleverPHLConfirmDialog(
255: cleverPHL,
256: this ,
257: language
258: .getString("CleverPHL.StartProgramDialog.Clear"),
259: language
260: .getString("CleverPHL.StartProgramDialog.Msg.Clear"),
261: language.getString("General.Yes"), language
262: .getString("General.No"));
263:
264: if (confirmDialog.getValue() == CleverPHLConfirmDialog.YES) {
265: session.getStarterList().clear();
266: }
267: } else if (source == removeButton) {
268: if (list.isSelectionEmpty()) {
269: new CleverPHLMsgDialog(
270: cleverPHL,
271: this ,
272: language.getString("General.Error"),
273: language
274: .getString("CleverPHL.StartProgramDialog.Error.NoSelectedStarter"),
275: language.getString("General.Ok"));
276: } else {
277: CleverPHLConfirmDialog confirmDialog = new CleverPHLConfirmDialog(
278: cleverPHL,
279: this ,
280: language
281: .getString("CleverPHL.StartProgramDialog.Remove"),
282: language
283: .getString("CleverPHL.StartProgramDialog.Msg.Remove"),
284: language.getString("General.Yes"), language
285: .getString("General.No"));
286:
287: if (confirmDialog.getValue() == CleverPHLConfirmDialog.YES) {
288: Starter removeStarter = (Starter) session
289: .getStarterList().getElementAt(
290: list.getSelectedIndex());
291: session.getStarterList().removeElement(
292: removeStarter);
293: }
294: }
295: } else if (source == loadButton) {
296: loadStarters();
297: } else if (source == saveButton) {
298: saveStarters();
299: } else if (source == applicationStarterButton) {
300: EditorDialog dialog = new EditorDialog(
301: this ,
302: language
303: .getString("CleverPHL.StartProgramDialog.NewApplicationStarter"),
304: new ApplicationStarter(env));
305:
306: if (dialog.getValue() == EditorDialog.OK) {
307: session.getStarterList()
308: .addElement(dialog.getStarter());
309: }
310: } else if (source == appletStarterButton) {
311: EditorDialog dialog = new EditorDialog(
312: this ,
313: language
314: .getString("CleverPHL.StartProgramDialog.NewAppletStarter"),
315: new AppletStarter(env));
316:
317: if (dialog.getValue() == EditorDialog.OK) {
318: session.getStarterList()
319: .addElement(dialog.getStarter());
320: }
321: } else if (source == editButton) {
322: if (list.isSelectionEmpty()) {
323: new CleverPHLMsgDialog(
324: cleverPHL,
325: this ,
326: language.getString("General.Error"),
327: language
328: .getString("CleverPHL.StartProgramDialog.Error.NoSelectedStarter"),
329: language.getString("General.Ok"));
330: } else {
331: Starter editStarter = (Starter) session
332: .getStarterList().getElementAt(
333: list.getSelectedIndex());
334: EditorDialog dialog = new EditorDialog(
335: this ,
336: language
337: .getString("CleverPHL.StartProgramDialog.Edit"),
338: editStarter);
339:
340: if (dialog.getValue() == EditorDialog.OK) {
341: if (editStarter instanceof ApplicationStarter) {
342: ((ApplicationStarter) editStarter)
343: .setValues((ApplicationStarter) dialog
344: .getStarter());
345: } else if (editStarter instanceof AppletStarter) {
346: ((AppletStarter) editStarter)
347: .setValues((AppletStarter) dialog
348: .getStarter());
349: }
350:
351: repaint();
352: }
353: }
354: }
355: }
356:
357: /**
358: * Closes this dialog and starts the selected program.
359: */
360: private void close() {
361: Session session = cleverPHL.getSessionList().getActual();
362:
363: if (list.isSelectionEmpty()) {
364: Language language = cleverPHL.getLanguage();
365: new CleverPHLMsgDialog(
366: cleverPHL,
367: this ,
368: language.getString("General.Error"),
369: language
370: .getString("CleverPHL.StartProgramDialog.Error.NoSelectedStarter"),
371: language.getString("General.Ok"));
372: } else {
373: setVisible(false);
374: selectedStarter = (Starter) session.getStarterList()
375: .getElementAt(list.getSelectedIndex());
376: dispose();
377: }
378: }
379:
380: /**
381: * Shows a file chooser dialog for loading a starter list.
382: */
383: private void loadStarters() {
384: Language language = cleverPHL.getLanguage();
385: Session session = cleverPHL.getSessionList().getActual();
386:
387: JFileChooser chooser = new JFileChooser(cleverPHL.getFiles()
388: .getDir("CLEVERPHL_STARTERS_DIR"));
389: chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
390: chooser
391: .setDialogTitle(language
392: .getString("CleverPHL.StartProgramDialog.LoadListDialog.Title"));
393: chooser
394: .setFileFilter(new ExtensionFileFilter(
395: "xml",
396: language
397: .getString("CleverPHL.StartProgramDialog.XMLFileFilter.Description")));
398:
399: int returnVal = chooser.showDialog(this , language
400: .getString("General.Load"));
401:
402: if (returnVal == JFileChooser.APPROVE_OPTION) {
403: String filename = chooser.getSelectedFile().getPath();
404:
405: if (!filename.toLowerCase().endsWith(".xml")) {
406: filename += ".xml";
407: }
408:
409: session.getStarterList().clear();
410: session.getStarterList().loadStarters(filename);
411: }
412: }
413:
414: /**
415: * Shows a file chooser dialog for saving a starter list.
416: */
417: private void saveStarters() {
418: Language language = cleverPHL.getLanguage();
419: Session session = cleverPHL.getSessionList().getActual();
420: JFileChooser chooser = new JFileChooser(cleverPHL.getFiles()
421: .getDir("CLEVERPHL_STARTERS_DIR"));
422: chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
423: chooser
424: .setDialogTitle(language
425: .getString("CleverPHL.StartProgramDialog.SaveListDialog.Title"));
426: chooser
427: .setFileFilter(new ExtensionFileFilter(
428: "xml",
429: language
430: .getString("CleverPHL.StartProgramDialog.XMLFileFilter.Description")));
431:
432: int returnVal = chooser.showDialog(this , language
433: .getString("General.Save"));
434:
435: if (returnVal == JFileChooser.APPROVE_OPTION) {
436: String filename = chooser.getSelectedFile().getPath();
437:
438: if (!filename.toLowerCase().endsWith(".xml")) {
439: filename += ".xml";
440: }
441:
442: session.getStarterList().saveStarters(filename);
443: }
444: }
445:
446: /**
447: * Returns the selected starter after this dialog has been closed, or <code>null</code> if no
448: * starter has been selected.
449: *
450: * @return DOCUMENT ME!
451: */
452: public Starter getSelectedStarter() {
453: return selectedStarter;
454: }
455:
456: /**
457: * Listener for the double click on the list elements.
458: */
459: static class ListMouseListener implements MouseListener {
460: //~ Instance fields ------------------------------------------------------------------------
461:
462: /** The dialog this listener belongs to. */
463: private StartProgramDialog dialog;
464:
465: //~ Constructors ---------------------------------------------------------------------------
466:
467: /**
468: * Creates a new listener object.
469: *
470: * @param dialog DOCUMENT ME!
471: */
472: public ListMouseListener(StartProgramDialog dialog) {
473: this .dialog = dialog;
474: }
475:
476: //~ Methods --------------------------------------------------------------------------------
477:
478: /**
479: * Calls the <code>notifyDoubleClick</code> method of the starter frame when the mouse has
480: * been double clicked.
481: *
482: * @param e the mouse event.
483: */
484: public void mouseClicked(MouseEvent e) {
485: if (e.getClickCount() == 2) {
486: dialog.close();
487: }
488: }
489:
490: public void mouseEntered(MouseEvent e) {
491: }
492:
493: public void mouseExited(MouseEvent e) {
494: }
495:
496: public void mousePressed(MouseEvent e) {
497: }
498:
499: public void mouseReleased(MouseEvent e) {
500: }
501: }
502:
503: /**
504: * A dialog for editing a starter.
505: */
506: class EditorDialog extends JDialog implements ActionListener {
507: //~ Static fields/initializers -------------------------------------------------------------
508:
509: /** Button "ok" has been pressed. */
510: public static final int OK = 0;
511:
512: /** Button "cancel" has been pressed. */
513: public static final int CANCEL = 1;
514:
515: //~ Instance fields ------------------------------------------------------------------------
516:
517: /** The ok button. */
518: private JButton okButton;
519:
520: /** The cancel button. */
521: private JButton cancelButton;
522:
523: /** <code>OK</code> or <code>CANCEL</code>. */
524: private int value;
525:
526: /** The editor for the starter. */
527: private Editor editor;
528:
529: //~ Constructors ---------------------------------------------------------------------------
530:
531: /**
532: * Creates a new editor dialog. The specified starter will be cloned for the editor.
533: *
534: * @param dialog DOCUMENT ME!
535: * @param title DOCUMENT ME!
536: * @param starter DOCUMENT ME!
537: */
538: public EditorDialog(StartProgramDialog dialog, String title,
539: Starter starter) {
540: super (dialog, title, true);
541:
542: Language language = cleverPHL.getLanguage();
543: okButton = new JButton(language.getString("General.Ok"));
544: okButton.addActionListener(this );
545: cancelButton = new JButton(language
546: .getString("General.Cancel"));
547: cancelButton.addActionListener(this );
548:
549: if (starter instanceof ApplicationStarter) {
550: editor = new ApplicationStarterEditor(env);
551: editor
552: .setElement((Starter) ((ApplicationStarter) starter)
553: .clone());
554: } else if (starter instanceof AppletStarter) {
555: editor = new AppletStarterEditor(env);
556: editor.setElement((Starter) ((AppletStarter) starter)
557: .clone());
558: }
559:
560: getContentPane().setLayout(new BorderLayout());
561:
562: JPanel editorPanel = new JPanel();
563: editorPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
564: editorPanel.add(editor.getComponent());
565: getContentPane().add(editorPanel, BorderLayout.NORTH);
566:
567: JPanel buttonPanel = new JPanel();
568: buttonPanel.add(okButton);
569: buttonPanel.add(cancelButton);
570: buttonPanel.setBorder(new EmptyBorder(10, 10, 10, 10));
571: getContentPane().add(buttonPanel, BorderLayout.SOUTH);
572: pack();
573:
574: Point ownerLoc = dialog.getLocation();
575: setLocation(((int) ownerLoc.getX()) + 20, ((int) ownerLoc
576: .getY()) + 20);
577: setResizable(false);
578: setVisible(true);
579: }
580:
581: //~ Methods --------------------------------------------------------------------------------
582:
583: /**
584: * Returns <code>OK</code> or <code>CANCEL</code> after one of the buttons has been
585: * pressed.
586: *
587: * @return DOCUMENT ME!
588: */
589: public int getValue() {
590: return value;
591: }
592:
593: /**
594: * Returns the starter edited by the editor.
595: *
596: * @return DOCUMENT ME!
597: */
598: public Starter getStarter() {
599: return (Starter) editor.getElement();
600: }
601:
602: /**
603: * Called when an action has been performed.
604: *
605: * @param e DOCUMENT ME!
606: */
607: public void actionPerformed(ActionEvent e) {
608: if (e.getSource() == okButton) {
609: Language language = cleverPHL.getLanguage();
610: Starter starter = getStarter();
611:
612: if ((starter.getName() == null)
613: || starter.getName().equals("")) {
614: new CleverPHLMsgDialog(
615: cleverPHL,
616: this ,
617: language.getString("General.Error"),
618: language
619: .getString("CleverPHL.StartProgramDialog.Error.NoName"),
620: language.getString("General.Ok"));
621: } else if ((starter.getClassname() == null)
622: || starter.getClassname().equals("")) {
623: new CleverPHLMsgDialog(
624: cleverPHL,
625: this ,
626: language.getString("General.Error"),
627: language
628: .getString("CleverPHL.StartProgramDialog.Error.NoClassname"),
629: language.getString("General.Ok"));
630: } else {
631: value = OK;
632: dispose();
633: }
634: } else {
635: value = CANCEL;
636: dispose();
637: }
638: }
639: }
640: }
|