/**
 * Created on: 15.06.2003<br>
 *
 * Filename: GUI.java<br>
 *
 * @author Isabell Clemens, Benjamin Balluff, Christian Kohler, Oliver Klais, Jannis Utz<br>
 */

import java.awt.*;
import java.awt.event.*;
import java.io.File;
import javax.swing.*;
import javax.swing.border.*;

/**
 * Description: Diese Klasse enthält die Benutzeroberfläche und die Verwaltung des Stundenplanes<br>
 *
 */
public class GUI extends JFrame implements ActionListener {
	/**
	 * Description: Dieses Feld enthält den Inhalt des Fensters<br>
 	 */
	private Container content;
	/**
	 * Description: Dieses Feld enthält den Teiler für das Fenster<br>
 	 */
	private JSplitPane split;
	/**
	 * Description: Dieses Feld enthält den Namen der Lehrveranstaltung<br>
 	 */
	private JTextField nameFeld;
	/**
	 * Description: Dieses Feld enthält den Raum der Lehrveranstaltung<br>
 	 */
	private JTextField raumFeld;
	/**
	 * Description: Dieses Feld enthält die möglichen Tage der Lehrveranstaltung<br>
 	 */
	private JComboBox tag;
	/**
	 * Description: Dieses Feld enthält die möglichen Anfangszeiten der Lehrveranstaltung<br>
 	 */
	private JComboBox anfangszeit;
	/**
	 * Description: Dieses Feld enthält die möglichen Endzeiten der Lehrveranstaltung<br>
 	 */
	private JComboBox endzeit;
	/**
	 * Description: Diese Buttons bestimmen die Art der Lehrveranstaltung<br>
 	 */
	private JRadioButton praktikumButton;
	private JRadioButton vorlesungButton;
	/**
	 * Description: Diese Felder bestimmen die möglichen Tage der Lehrveranstaltung, d.h.
	 * durch erhöhen der Tage kann man den Samstag bzw. Sonntag zusätzlich einblenden.
 	 * (Diese Funktionalität, ist für die Speichernfunktion nicht fertig implementiert)<br>
 	 */
	private final int TAGE = 5, STUNDEN = 12;
	/**
	 * Description: Zeiger auf das Objekt StundenplanArray, und damit auf das
	 * Array _woche.<br>
 	 */
	private StundenplanArray stdplan;
	/**
     * Description: Dieses Feld enthält die im Programm verwendete Schriftart<br>
 	 */
	private static final Font ENTRYFONT = new Font("Arial", Font.BOLD, 12);
	/**
	 * Description: Dieses Feld enthält die Breite des Programmfensters<br>
 	 */
	static int WIDTH = 900;
	/**
	 * Description: Dieses Feld enthält die Höhe des Programmfensters<br>
 	 */
	static int HEIGHT = 500;


	/**
	 * Description: Konstruktor der Benutzeroberfläche<br>
	 *
	 * @param Der Titel des Fensters, dass angezeigt wird<br>
	 */
	public GUI(String title) {
		super(title);

		// Look and Feel auf Windows anpassen. Achtung nur auf Windows getestet!
		try {
			UIManager.setLookAndFeel(
				"com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
			SwingUtilities.updateComponentTreeUI(this);
		} catch (Exception e) {
		}

		// Erzeugt bei Programmstart ein neues, leeres Stundenplanarray
		stundenplanInit();
		// Hintergrundfarbe der Menüleiste
		setBackground(Color.lightGray);

		// Splitpane erzeugen (Zweiteilung des Fensters)
		split = new JSplitPane();
		getContentPane().add(split);

		// Eingabepanel auf der linken Seite
		JPanel linkesPanel = new JPanel(new BorderLayout());
		split.setLeftComponent(linkesPanel);

		// StundenplanPanel auf der rechten Seite
		JPanel rechtesPanel = new JPanel(new BorderLayout());
		split.setRightComponent(rechtesPanel);

		// Setup des Fensters

		// Setup Menüs

		// Menüleiste wird erzeugt
		JMenuBar menuBar = new JMenuBar();
		setJMenuBar(menuBar);

		/* Die Accelerators werden nur auf einigen JREs angezeigt.
		 Mit der im SDK 1.4.1_03 enthaltenen Version haben wir Probleme gehabt,
		 in der FH werden sie korrekt angezeigt.
		 Es wird zur Sicherheit unter Tipps & Tricks darauf hingewiesen*/
		// Menüleisteneintrag "Datei" wird erzeugt, accelerator D [Alt + d]
		JMenu file = new JMenu("Datei");
		file.setMnemonic(KeyEvent.VK_D);

		// Menüpunkt "Neu" wird erzeugt, accelerator N [Alt + n]
		// stundenplanNeu wird aufgerufen, wenn es ausgewählt wird
		JMenuItem item;
		file.add(item = new JMenuItem("Neu"));
		item.setMnemonic(KeyEvent.VK_N);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				stundenplanNeu();
			}
		});

		// Menüpunkt "Oeffnen" wird erzeugt, accelerator O [Alt + o]
		// dateiOeffnen wird aufgerufen, wenn es ausgewählt wird
		file.add(item = new JMenuItem("Oeffnen"));
		item.setMnemonic(KeyEvent.VK_O);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				dateiOeffnen();
			}
		});

		// Menüpunkt "Speichern" wird erzeugt, accelerator S [Alt + s]
		// dateiSpeichern wird aufgerufen, wenn es ausgewählt wird
		file.add(item = new JMenuItem("Speichern"));
		item.setMnemonic(KeyEvent.VK_S);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				dateiSpeichern();
			}
		});

		// Ein separator wird eingefügt, um "Beenden" etwas abzusetzen
		file.addSeparator();

		// Menüpunkt "Beenden" wird erzeugt, accelerator B [Alt + b]
		// beenden wird aufgerufen, wenn es ausgewählt wird
		file.add(item = new JMenuItem("Beenden"));
		item.setMnemonic(KeyEvent.VK_B);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				beenden(0);
			}
		});

		// Dateimenü wird der Menüleiste hinzugefügt
		menuBar.add(file);

		//Ein Menüleisteneintrag "Hilfe" wird erzeugt, accelerator H [Alt + h]
		JMenu help = new JMenu("Hilfe");
		help.setMnemonic(KeyEvent.VK_H);

		// Ein Menüpunkt "Hilfe" wird erzeugt, accelerator T [Alt + t]
		// infoAnzeigen wird aufgerufen, wenn es ausgewählt wird
		help.add(item = new JMenuItem("Tipps & Tricks"));
		item.setMnemonic(KeyEvent.VK_T);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				hilfeAnzeigen();
			}
		});

		// Ein Menü "Info" wird erzeugt, accelerator I [Alt + i]
		// infoAnzeigen wird aufgerufen, wenn es ausgewählt wird
		help.add(item = new JMenuItem("Info"));
		item.setMnemonic(KeyEvent.VK_I);
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				infoAnzeigen();
			}
		});

		// Das Hilfe Menü wird der Menüleiste hinzugefügt
		menuBar.add(help);

		// der Container wird geholt
		// und das Layout wird als einfaches BorderLayout gesetzt
		content = getContentPane();
		// das eingabePanel wird hinzugefügt,
		// das alle Felder des linkes Fensters beinhaltet
		linkesPanel.add(createEingabePanel(), BorderLayout.CENTER);
		// der ButtonPanel wird hinzugefügt,
		// der alle Buttons des linken Fensters beinhaltet.
		linkesPanel.add(createButtonPanel(), BorderLayout.SOUTH);
		// stundenplanPanel wird hinzugefügt,
		// das alle Felder des linkes Fensters beinhaltet
		rechtesPanel.add(createStundenplanPanel(), BorderLayout.CENTER);
		pack();
	}

	/**
	 * Description: Diese Methode konstruiert das EingabePanel für das Fenster, in dem sich
	 * alle Eingabefelder befinden.<br>
	 *
	 * @return Eingabepanel mit allen Feldern für die Eingaben des Benutzers<br>
	 */
	public JPanel createEingabePanel() {
		// der Panel wird generiert und bekommt als Layout das GridBagLayout
		JPanel eingabePanel = new JPanel(new GridBagLayout());
		// der Panel bekommt einen Rahmen mit Titel
		eingabePanel.setBorder(
			new TitledBorder(
				new EtchedBorder(
					EtchedBorder.RAISED,
					new Color(255, 255, 255),
					new Color(0, 0, 0)),
				"Stundeneingabe"));

		// GridBigConstraints werden geholt, um die Elemente im Panel zu
		// koordinieren
		GridBagConstraints constraints = new GridBagConstraints();
		// alle Elemente werden nach rechts orientiert
		constraints.anchor = GridBagConstraints.NORTHWEST;
		// jedes Element bekommt einen bestimmten Rahmen
		constraints.insets = new Insets(5, 5, 5, 10);

		// speichert die yKoordinate jedes Elements
		int position = 0;

		/*******************
		 * Name des Faches *
		 ******************/
		// Label für Fach
		JLabel label = new JLabel("Fach: ");
		// Schriftdefinition wird geholt
		label.setFont(ENTRYFONT);
		//Label wird hinzugefügt
		eingabePanel.add(label, constraints);
		// Neues Text Feld wird angelegt
		nameFeld = new JTextField();
		//Der ActionListener wird gesetzt
		nameFeld.addActionListener(this);
		// Die Größe des Text Feldes wird festgelegt
		nameFeld.setPreferredSize(new Dimension(95, 20));
		// Das Text Feld wird nach rechts (1) positioniert
		constraints.gridx = 1;
		// Das Text Feld wird dem Panel hinzugefügt
		eingabePanel.add(nameFeld, constraints);

		/***********************
		 * Art des Unterrichts *
		 **********************/
		// Label für Art des Unterrichts
		label = new JLabel("Art des Unterrichts: ");
		// Schriftdefinition wird geholt
		label.setFont(ENTRYFONT);
		// Label wird linksbündig gesetzt
		constraints.gridx = 0;
		// Label wird in die nächste Zeile eingefügt
		constraints.gridy = ++position;
		// Das Label wird dem Panel hinzugefügt
		eingabePanel.add(label, constraints);
		/* die beiden RadioButtons werden generiert
		 * das die Unterrichtsart in Vorlesung oder Praktikum
		 * aufteilt */
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 0));
		// Die Buttongroup wird angelegt
		ButtonGroup buttonGroup = new ButtonGroup();
		// Der Praktikum Button wird angelegt
		praktikumButton = new JRadioButton("Praktikum");
		// Die Auswahl kann über [Alt + p] abkürzen
		praktikumButton.setMnemonic('P');
		buttonGroup.add(praktikumButton);

		// Vorlesung Button wird angelegt
		vorlesungButton = new JRadioButton("Vorlesung", true);
		// Die Auswahl kann über [Alt + v] abkürzen
		vorlesungButton.setMnemonic('V');
		// Buttons werden als Gruppe dem Panel hinzugefügt
		buttonGroup.add(vorlesungButton);
		buttonPanel.add(vorlesungButton);
		buttonPanel.add(praktikumButton);
		// Die beiden Radiobuttons werden beim ActionListener registriert
		praktikumButton.addActionListener(this);
		vorlesungButton.addActionListener(this);
		// buttonPanel wird an der zweiten Position von links dem EingabePanel übergeben
		constraints.gridx = 1;
		eingabePanel.add(buttonPanel, constraints);

		/*************
		 * Wochentag *
		 ************/
		label = new JLabel("Wochentag: ");
		label.setFont(ENTRYFONT);
		constraints.gridwidth = 1;
		constraints.gridx = 0;
		constraints.gridy = ++position;
		constraints.fill = GridBagConstraints.NONE;
		eingabePanel.add(label, constraints);
		// Das Pulldownmenü wird daneben angelegt
		tag = new JComboBox();
		// Höhe und Breite der Menüzellen wird festgelegt
		tag.setPreferredSize(new Dimension(95, 20));
		// Einzelne Einträge werden dem Pulldownmenü hinzugefügt
		tag.addItem("Montag");
		tag.addItem("Dienstag");
		tag.addItem("Mittwoch");
		tag.addItem("Donnerstag");
		tag.addItem("Freitag");
		if (TAGE > 5) {
			tag.addItem("Samstag");
		}
		if (TAGE > 6) {
			tag.addItem("Sonntag");
		}
		//
		tag.addActionListener(this);
		constraints.gridx = 1;
		eingabePanel.add(tag, constraints);

		/*******************************
		 * Anfangszeit des Unterrichts *
		 ******************************/
		label = new JLabel("Anfangszeit: ");
		label.setFont(ENTRYFONT);
		constraints.gridwidth = 1;
		constraints.gridx = 0;
		constraints.gridy = ++position;
		constraints.fill = GridBagConstraints.NONE;
		eingabePanel.add(label, constraints);
		anfangszeit = new JComboBox();
		// Höhe und Breite der Menüzellen wird festgelegt
		anfangszeit.setPreferredSize(new Dimension(95, 20));
		anfangszeit.addItem(" 8:00 Uhr");
		anfangszeit.addItem(" 9:00 Uhr");
		anfangszeit.addItem("10:00 Uhr");
		anfangszeit.addItem("11:00 Uhr");
		anfangszeit.addItem("12:00 Uhr");
		anfangszeit.addItem("13:00 Uhr");
		anfangszeit.addItem("14:00 Uhr");
		anfangszeit.addItem("15:00 Uhr");
		anfangszeit.addItem("16:00 Uhr");
		anfangszeit.addItem("17:00 Uhr");
		anfangszeit.addItem("18:00 Uhr");
		anfangszeit.addItem("19:00 Uhr");
		constraints.gridx = 1;
		eingabePanel.add(anfangszeit, constraints);

		/************************
		 * Ende des Unterrichts *
		 ***********************/
		label = new JLabel("Ende: ");
		label.setFont(ENTRYFONT);
		constraints.gridwidth = 1;
		constraints.gridx = 0;
		constraints.gridy = ++position;
		constraints.fill = GridBagConstraints.NONE;
		eingabePanel.add(label, constraints);
		endzeit = new JComboBox();
		// Höhe und Breite der Menüzellen wird festgelegt
		endzeit.setPreferredSize(new Dimension(95, 20));
		endzeit.addItem(" 9:00 Uhr");
		endzeit.addItem("10:00 Uhr");
		endzeit.addItem("11:00 Uhr");
		endzeit.addItem("12:00 Uhr");
		endzeit.addItem("13:00 Uhr");
		endzeit.addItem("14:00 Uhr");
		endzeit.addItem("15:00 Uhr");
		endzeit.addItem("16:00 Uhr");
		endzeit.addItem("17:00 Uhr");
		endzeit.addItem("18:00 Uhr");
		endzeit.addItem("19:00 Uhr");
		endzeit.addItem("20:00 Uhr");
		constraints.gridx = 1;
		eingabePanel.add(endzeit, constraints);

		/*********************************
		* Eingabe des Raumes/Raumnummer *
		* ******************************/
		label = new JLabel("Raum: ");
		label.setFont(ENTRYFONT);
		constraints.gridx = 0;
		constraints.gridy = ++position;
		eingabePanel.add(label, constraints);
		raumFeld = new JTextField();
		raumFeld.addActionListener(this);
		raumFeld.setPreferredSize(new Dimension(95, 20));
		constraints.gridx = 1;
		eingabePanel.add(raumFeld, constraints);

		return eingabePanel;
	}

	/**
	 * Description: Diese Methode konstruiert die Buttons "Daten übernehmen" und
	 * "Maske löschen" für die linke untere Seite<br>
	 *
	 * @return Buttons "Daten übernehmen" und "Maske löschen"<br>
	 */
	public JPanel createButtonPanel() {
		// das Panel speichert die Buttons des Fensters
		JPanel buttonPanel = new JPanel();
		buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
		// ein Button zur Speicherung der Eingabe wird erzeugt.
		JButton submitButton = new JButton("Daten übernehmen");
		submitButton.addActionListener(this);
		buttonPanel.add(submitButton);

		// ein Button, um das Fenster zu schließen wird erzeugt
		// Der Button soll später das EingabePanel zurücksetzen
		JButton quitButton = new JButton("Maske löschen");
		quitButton.addActionListener(this);
		buttonPanel.add(quitButton);

		return buttonPanel;
	}

	/**
	 * Description: Diese Methode gibt den Zeiger stdplan zurück<br>
	 *
	 * @return  Zeiger auf den StundenplanArray<br>
	 */
	public StundenplanArray getStundenplanArray() {
		return stdplan;
	}

	/**
	 * Description: Diese Methode aktualisiert das Stundenplanpanel<br>
	 */
	public void refreshPanel() {
		split.setRightComponent(createStundenplanPanel());
	}

	/**
	 * Description: Diese Methode übergibt dem Eingabepanel eine Lehrveranstaltung zum
	 * bearbeiten<br>
	 *
	 * @param l Objekt des Types Lehrveranstaltung, welches die Daten der auf
	 * dem Stundenplanpanel angeklickten Lehrveranstaltung enthält<br>
	 */
	public void editAuswahl(Lehrveranstaltung l) {
		// Belegt die Felder mit den Daten der Lehrveranstaltung
		nameFeld.setText(l.getFach());
		raumFeld.setText(l.getRaum());
		tag.setSelectedIndex(l.getTag());
		anfangszeit.setSelectedIndex(l.getBeginn());
		endzeit.setSelectedIndex(l.getEnde());
		// Setzt die Art der Lehrveranstaltung,
		// je nachdem ob es sich um ein Praktikumsobjekt oder ein Vorlesungsobjekt handelt
		if (l instanceof Praktikum)
			praktikumButton.setSelected(true);
		else
			vorlesungButton.setSelected(true);

	}

	/**
	 * Description: Diese Methode erzeugt das Stundenplanpanel auf der rechten
	 * Bildschirmseite<br>
	 *
	 * @return Panel, welches den Stundenplan anzeigt<br>
	 */
	public JPanel createStundenplanPanel() {
		// das Panel wird generiert und bekommt als Layout das GridBagLayout
		JPanel stundenplanPanel = new JPanel(new GridBagLayout());
		stundenplanPanel.setBackground(Color.white);
		// das Panel bekommt einen Rahmen mit Titel
		stundenplanPanel.setBorder(
			new TitledBorder(
				new EtchedBorder(
					EtchedBorder.RAISED,
					new Color(255, 255, 255),
					new Color(0, 0, 0)),
				"Stundenplan"));

		/**********************************
		 * Wochentage für den Stundenplan *
		 *********************************/

		// Constraints werden erzeugt
		GridBagConstraints gbc = new GridBagConstraints();
		// das gbc wird verankert
		gbc.anchor = GridBagConstraints.NORTHWEST;
		String[] labels =
			{
				" Zeit",
				"         Montag",
				"         Dienstag",
				"         Mittwoch",
				"         Donnerstag",
				"         Freitag",
				"         Samstag",
				"         Sonntag" };

		// erzeugt die Label für die Wochentage
		for (int i = 0; i < TAGE + 1; i++) {
			//Label
			Label label = new Label(labels[i]);
			gbc.gridx = i;
			gbc.gridy = 0;
			// fügt die Wochentaglabels hinzu
			stundenplanPanel.add(label, gbc);

			// erzeugt die Zeitleiste
			for (int j = 1; j < (STUNDEN + 1); j++) {
				//Panel
				JPanel panel;

				if (i == 0) {
					panel = new JPanel();
					panel.setBackground(Color.white);
					// Die Beschriftung für die Zeitleiste wird dynamisch erzeugt
					panel.add(
						new Label(
							Integer.toString(j + 7)
								+ " - "
								+ Integer.toString(j + 8)));
					gbc.gridx = i;
					gbc.gridy = j;
					// fügt die Zeitlabels hinzu
					stundenplanPanel.add(panel, gbc);
				}
			}
			//
			gbc.fill = GridBagConstraints.BOTH;
			gbc.weightx = 50;

			// y Koordinaten (Stunden)
			for (int k = 1; k < (TAGE + 1); k++) {
				// x Koordinaten (Wochentage)
				for (int l = 1; l < (STUNDEN + 1); l++) {
					// Objekte werden dynamisch aus dem StundenplanArray ausgelesen
					Lehrveranstaltung fueller = stdplan.ausgabe(k - 1, l - 1);
					gbc.gridx = k;
					// wenn der Inhalt des Stundenplanobjektes nicht null ist, wird ein der Platz in den Constraints
					if (fueller != null) {
						int x = fueller.getBeginn();
						int y = fueller.getEnde();
						int z = y - x;
						gbc.gridheight = z + 1;
						gbc.gridy = l;
						l = l + z;
						// ein Panel wird mit Inhalt gefüllt
						stundenplanPanel.add(
							new StundenplanEintrag(fueller, this),
							gbc);
					} // Ein leeres Panel wird erzeugt
					else {
						stundenplanPanel.add(new JLabel(), gbc);
					}

					gbc.gridheight = 1;
				}
			}
		}
		return stundenplanPanel;
	}

	/**
	 * Description: Die Main Methode
	 *
	 */
	public static void main(String args[]) {
		// Der Frame wird erzeugt und erhällt seinen Titel
		GUI frame = new GUI("Stundenplanverwaltung");

		frame.addWindowListener(new WindowAdapter() {
			// Wenn das Fenster geschlossen wird wird auch das Programm beendet
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		// Größe wird übernommen
		frame.setSize(WIDTH, HEIGHT);
		frame.setVisible(true);
	}

	/**
	 * Description: Diese Methode erstellt beim Aufruf von "Neu" in der Menüleiste
	 * ein LEERES (nicht neues) Stundenplanarray<br>
	 */
	void stundenplanNeu() {
		// Confirm Dialog wird angezeigt und die Auswahl ausgewertet
		int confirm =
			JOptionPane.showConfirmDialog(
				this,
				"Wollen Sie die Änderung speichern?",
				"Achtung",
				JOptionPane.YES_NO_CANCEL_OPTION);
		// speichern und neuen leeren Stundenplan erzeugen
		if (confirm == 0) {
			dateiSpeichern();
			stdplan.planLoeschen(TAGE, STUNDEN);
			split.setRightComponent(createStundenplanPanel());
			// Inhalt wird verworfen und ein leerer Stundenplan wird angelegt
		} else if (confirm == 1) {
			stdplan.planLoeschen(TAGE, STUNDEN);
			split.setRightComponent(createStundenplanPanel());
		}
	} // wird aufgerufen, wenn das Info Menü ausgewählt wird

	/**
	 * Description: Diese Methode zeigt bei Aufruf von "Info" in der Menüleiste das Infofenster an<br>
	 */
	void infoAnzeigen() {
		// das Infofenster "Info" wird generiert
		final JDialog dialog = new JDialog(this, "Info", true);
		dialog.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				dialog.dispose();
			}
		});
		// im Infofenster wird ein scrollbares Fenster aufgebaut
		JScrollPane scroll = new JScrollPane();
		JEditorPane inhalt = new JEditorPane();
		inhalt.setContentType("text/html; charset=EUC-JP");
		//inhalt.setContentType("font-family:Arial,sans-serif;");
		inhalt.setEditable(false);
		// Inhalt der Infoanzeige; der Zeilenumbruch wird durch HTML Code erreicht
		inhalt.setText(
			"<html>"
				+ "<h2><font face=\"Arial, Helvetica, sans-serif\">Stundenplanverwaltung </font></h2>"
				+ "<h3><font face=\"Arial, Helvetica, sans-serif\">Version 1.0 </font></h3>"
				+ "<font face=\"Arial, Helvetica, sans-serif\">von<br>"
				+ "Isabell Clemens,<br>"
				+ "Christian Kohler,<br>"
				+ "Benjamin Balluff,<br>"
				+ "Oliver Klais<br>"
				+ "und Jannis Utz<br><br>"
				+ "Das Programm ist als Projektarbeit an der FH Weihenstephan im SS03 entstanden<br><br>"
				+ "http://www.karlshof.dyndns.org/Stundenplanverwaltung.html"
				+ "</font>"
				+ "</html>");
		dialog.getContentPane().add(scroll, BorderLayout.CENTER);
		scroll.setViewportView(inhalt);
		// schließen Button für das Info Feld
		JButton butt = new JButton("schließen");
		dialog.getContentPane().add(butt, BorderLayout.SOUTH);
		butt.addActionListener(new ActionListener() {
			// Beim Drücken des Schließen Buttons wird der Dialog ausgeblendet...
			public void actionPerformed(ActionEvent e) {
				dialog.setVisible(false);
				// ...und dem garbage Collector bereitgestellt
				dialog.dispose();
			}
		});
		// Die Größe des Info Dialogs wird festgesetzt...
		dialog.setSize(500, 400);
		// ...und der Dialog angezeigt
		dialog.setVisible(true);
	} // wird aufgerufen, wenn das Tipps & Tricks Menü ausgewählt wird

	/**
	 * Description: Diese Methode zeigt bei Aufruf von "Tipps & Tricks" in der Menüleiste
	 * das Tipps und Tricks Fenster an<br>
	 */
	void hilfeAnzeigen() {
		// das "Tipps & Tricks" Fenster wird generiert
		final JDialog dialog = new JDialog(this, "Tipps & Tricks", true);
		dialog.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				dialog.dispose();
			}
		});
		// im Hilfefenster wird ein scrollbares Fenster aufgebaut
		JScrollPane scroll = new JScrollPane();
		JEditorPane inhalt = new JEditorPane();
		inhalt.setContentType("text/html; charset=EUC-JP");
		inhalt.setEditable(false);
		// Das Tipps & Tricks Label bekommt seinen Inhalt
		inhalt.setText(
			"<html>"
				+ "<font face=\"Arial, Helvetica, sans-serif\">"
				+ "Shortcuts können für alle Eingabeoptionen verwendet werden:"
				+ "<ul>"
				+ "<li>Datei: [Alt + d]</li>"
				+ "<li>Neu: [Alt + n]</li>"
				+ "<li>Oeffnen: [Alt + o]</li>"
				+ "<li>Speichern: [Alt + s]</li>"
				+ "<li>Beenden: [Alt + b]</li>"
				+ "</ul>"
				+ "<ul>"
				+ "<li>Hilfe: [Alt + h]</li>"
				+ "<li>Tipps & Tricks: [Alt + t]</li>"
				+ "<li>Info: [Alt + i]</li>"
				+ "</ul>"
				+ "<ul>"
				+ "<li>Praktikum: [Alt + p]</li>"
				+ "<li>Vorlesung: [Alp + v]</li>"
				+ "</ul>"
				+ "Per Mausklick können im Stundenplan Fenster Lehrveranstaltungen bearbeitet und gelöscht werden!<br><br>"
				+ "Lehrveranstaltungen können leicht an mehreren Tagen eingetragen werden, "
				+ "da die Maske nach einer Eingabe nicht gelöscht wird"
				+ "</font>"
				+ "</html>");
		dialog.getContentPane().add(scroll, BorderLayout.CENTER);
		scroll.setViewportView(inhalt);
		// schließen Button für das Info Feld
		JButton butt = new JButton("schließen");
		// Button wird dem Dialog hinzugefügt
		dialog.getContentPane().add(butt, BorderLayout.SOUTH);
		butt.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				// Beim verlassen wird der Dialog ausgeblendet...
				dialog.setVisible(false);
				// ...und dem garbage Collector bereitgestellt
				dialog.dispose();
			}
		});
		// Die Größe des Tipps & Tricks Dialogs wird festgesetzt...
		dialog.setSize(500, 450);
		// ...und der Dialog angezeigt
		dialog.setVisible(true);
	} // wird aufgerufen, wenn das Beenden Menü ausgewählt wird

	/**
	 * Description: Diese Methode beendet das Programm bei Aufruf<br>
	 *
	 * @param status, Art des Programmendes<br>
	 */
	void beenden(int status) {
		// Speicherndialog wird angezeigt, falls die Beendenfunktion aufgerufen wird
		int confirm =
			JOptionPane.showConfirmDialog(
				this,
				"Wollen Sie den Stundenplan speichern ?",
				"Achtung",
				JOptionPane.YES_NO_CANCEL_OPTION);
		// Ja, Daten sollen gespeichert werden
		if (confirm == 0) {
			// Daten werden gespeichert
			dateiSpeichern();
			// Das Programm wird beendet
			System.exit(status);
		} // Nein, Daten werden verworfen und das Programm beendet
		else if (confirm == 1) {
			// Das Programm wird beendet
			System.exit(status);
		}

	}

	/**
	 * Description: Diese Methode konstruiert den Datei-Speichern Dialog<br>
	 */
	void dateiSpeichern() {
		// Speichern-Dialog bekommt seine Eigenschaften zugewiesen
		JFileChooser speichern = new JFileChooser();
		speichern.addChoosableFileFilter(new DateiFilter("*.stpl", "stpl"));
		speichern.setAcceptAllFileFilterUsed(false);
		speichern.setCurrentDirectory(new File("."));
		speichern.setDialogTitle("Speichern...");
		speichern.setApproveButtonText("Speichern");

		if (speichern.showOpenDialog(getContentPane())
			!= JFileChooser.APPROVE_OPTION) {
			return;
		}
		// Die Methode zum speichern des StundenplanArrays wird aufgerufen; als Speicherpfad wird
		// dabei die im Speichern-Dialog ausgewählte(eingegebene) Datei übergeben
		stdplan.stdplanSpeichern(speichern.getSelectedFile());
		// Eine Ausgabe informiert bei erfolgreicher Speicherung
		JOptionPane.showMessageDialog(
			getContentPane(),
			"Der Inhalt des Stundenplans wurde in der Datei"
				+ speichern.getSelectedFile()
				+ " gespeichert!",
			"Information",
			JOptionPane.PLAIN_MESSAGE);
	}

	/**
	 * Description: Diese Methode konstruiert den Datei-Öffnen Dialog<br>
	 */
	void dateiOeffnen() {
		// Öfnnen-Dialog bekommt seine Eigenschaften zugewiesen
		JFileChooser laden = new JFileChooser();
		laden.addChoosableFileFilter(new DateiFilter(".stpl", "stpl"));
		laden.setAcceptAllFileFilterUsed(false);
		laden.setCurrentDirectory(new File("."));
		laden.setDialogTitle("Öffnen...");
		laden.setApproveButtonText("Öffnen");

		if (laden.showOpenDialog(getContentPane())
			!= JFileChooser.APPROVE_OPTION) {
			return;
		}
		// Die Methode zum Laden der Datei wird aufgerufen, der Pfad der zu ladenden Datei wird mit
		// übergeben
		stdplan.stdplanLaden(laden.getSelectedFile());
		// akualisiert StundenplanPanel
		refreshPanel();
	}

	/**
	 * Description: Diese Methode kreiert ein NEUES, leeres Stundenplanarray<br>
	 */
	public void stundenplanInit() {
		stdplan = new StundenplanArray(TAGE, STUNDEN, this);
	}

	/***********************************************************************************************
	*                                       ACTION LISTENER                                        *
	***********************************************************************************************/

	/**
	 * Description: "actionPerformed" Methode, die auf Events reagiert<br>
	 *
	 * @param e Die Aktion, die der Benutzer ausgeführt hat<br>
	 */
	public void actionPerformed(ActionEvent e) {
		// die Stringrepräsentation der Aktion wird geholt
		String command = e.getActionCommand();

		// falls "Maske löschen" gewählt wurde...
		if (command.equals("Maske löschen")) {
			// ... werden alle Eingabefelder des Eingabepanels gecleared
			nameFeld.setText("");
			raumFeld.setText("");
			tag.setSelectedIndex(0);
			anfangszeit.setSelectedIndex(0);
			endzeit.setSelectedIndex(0);
		}
		// falls die Daten übernommen werden sollen
		else if (command.equals("") || command.equals("Daten übernehmen")) {
			// Überprüft ob Eingaben gemacht worden sind. Wenn ja...
			if (!(nameFeld.getText().equals("")
				|| raumFeld.getText().equals(""))) {
				// ... werden Eingaben ausgelesen
				String fach = nameFeld.getText();
				String raum = raumFeld.getText();
				int tagIndex = tag.getSelectedIndex();
				int beginn = anfangszeit.getSelectedIndex();
				int ende = endzeit.getSelectedIndex();

				// Überprüft ob die Anfangszeit < der Endzeit ist. Wenn ja...
				if (beginn <= ende) {

					// ... wird hier ein Objekt der Klasse Praktikum mit den eingegebene Daten
					// erzeugt
					if (praktikumButton.isSelected() == true) {
						Praktikum pneu = new Praktikum();
						pneu.setFach(fach);
						pneu.setRaum(raum);
						pneu.setTag(tagIndex);
						pneu.setBeginn(beginn);
						pneu.setEnde(ende);
						// for testing
						//pneu.print();

						// Erzeugen zweier Test-Lehrveranstaltungen
						Lehrveranstaltung testBeginn = new Lehrveranstaltung();
						Lehrveranstaltung testEnde = new Lehrveranstaltung();
						// test1 zeigt nun auf den Inhalt des Arrays an der Stelle (tag,beginn)
						testBeginn = stdplan.testBeginn(tagIndex, beginn);
						// test2 zeigt nun auf den Inhalt des Arrays an der Stelle (tag,ende)
						testEnde = stdplan.testEnde(tagIndex, ende);
						// zeigen beide tests auf leere Speicherplätze, so kann zw. diesen das
						// Praktikum eingefügt werden
						if (testBeginn == null && testEnde == null) {
							stdplan.hinzufuegenP(tagIndex, pneu, beginn, ende);
							refreshPanel();
						}
						// zeigt nur eine der beiden tests auf belegten Speicherplatz wird
						// Fehlermeldung ausgegeben
						else {
							JOptionPane.showMessageDialog(
								getContentPane(),
								"Zum angegebenen Zeitpunkt gibt es schon eine Lehrveranstaltung."
									+ " Sie müssen diese erst entfernen",
								"Fehler",
								JOptionPane.ERROR_MESSAGE);
						}
					}

					// Hier wird ein Objekt der Klasse Vorlesung mit den eingegebene Daten
					// erzeugt
					if (vorlesungButton.isSelected() == true) {
						Vorlesung vneu = new Vorlesung();
						vneu.setFach(fach);
						vneu.setRaum(raum);
						vneu.setTag(tagIndex);
						vneu.setBeginn(beginn);
						vneu.setEnde(ende);
						// for testing
						//vneu.print();
						// Das gleiche Testverfahren wie beim Praktikum
						Lehrveranstaltung test1 = new Lehrveranstaltung();
						Lehrveranstaltung test2 = new Lehrveranstaltung();
						test1 = stdplan.testBeginn(tagIndex, beginn);
						test2 = stdplan.testEnde(tagIndex, ende);
						if (test1 == null && test2 == null) {
							stdplan.hinzufuegenV(tagIndex, vneu, beginn, ende);
							refreshPanel();
						} else {
							JOptionPane.showMessageDialog(
								getContentPane(),
								"Zum angegebenen Zeitpunkt gibt es schon eine Lehrveranstaltung. Bitte löschen Sie erst diese!",
								"Fehler",
								JOptionPane.ERROR_MESSAGE);
						}
					}
				}
				// Anzeige einer Fehlermeldung bei falscher der Eingabe der Uhrzeiten
				// z.B. Anfangszeit > Endzeit
				else {
					JOptionPane.showMessageDialog(
						getContentPane(),
						"Korrigieren sie Ihre Uhrzeiteingaben !",
						"Fehler",
						JOptionPane.ERROR_MESSAGE);
				}
				// Anzeige eines Hinweises, falls Daten zum Hinzufügen einer Lehrveranstaltung zum
				// StundenplanArray fehlen
			} else {
				JOptionPane.showMessageDialog(
					this,
					"Sie müssen ein Fach und einen Raum eingeben.",
					"Information",
					JOptionPane.INFORMATION_MESSAGE);
			}
		}
	}
}