/**
 *
 * Programmieraufgabe P-11 (Tabelle.java)
 *
 * @author Leonhard Fellermayr
 * @version 1.0
 */

/** Benoetigte Packages: Wir erweitern die Klasse Applet und benoetigen
 *  die Dienste des AWT
 */

import java.applet.Applet;
import java.awt.*;

/** Implementierung der Klasse Tabelle gemaess Aufgabenstellung
  *
  * erweitert: Applet
  *
  */

public class Tabelle extends Applet {

	/** Abstand zum Rand (horizontal = PADDING_X, vertikal = PADDING_Y */

	final int PADDING_X = 30;
	final int PADDING_Y = 30;

	/** Groesse der Multiplikationstabelle (Zahlen 1..TABLE_SIZE).
	    Die Tabelle ist stets quadratisch: TABLE_SIZE x TABLE_SIZE */

	final int TABLE_SIZE = 9;

	/** Die Zahlen haben vom rechten bzw. unteren Zellrand den Abstand
	  * xOffset / OFFSET_FACTOR bzw. yOffset / OFFSET_FACTOR.
	  *
	  **/

	final double OFFSET_FACTOR = 1.6;

	/** PRIVATE METHODS */

	/**
	  * drawMatrix () : Zeichne die Multiplikationstabelle.
	  *
	  * @param g Graphics
	  * @param tableSize Groesse der Tabelle
	  * @param xStart linke obere Ecke der Tabelle (x)
	  * @param yStart linke obere Ecke der Tabelle (y)
	  * @param xEnd rechte untere Ecke der Tabelle (x)
	  * @param yEnd rechte untere Ecke der Tabelle (y)
	  *
	  * @return void
	  *
	  */

	private void drawMatrix (Graphics g, int tableSize, int xStart, int yStart, int xEnd, int yEnd) {

		/** Berechne Breite und Hoehe der einzelnen Tabellenzellen, abhaengig vom
		  * zur Verfuegung stehenden Platz und von der Groesse der Tabelle
		  **/

		int xOffset = (xEnd - xStart) / (tableSize + 1);
		int yOffset = (yEnd - yStart) / (tableSize + 1);

		/** (Horizontaler) Abstand der Zahlen vom rechten Zellenrand */
		int numPadX = (int)(xOffset / OFFSET_FACTOR);

		/** (Vertikaler) Abstand der Zahlen vom oberen Zellenrand */
		int numPadY = (int)(yOffset / OFFSET_FACTOR);

		/** In dieser Variablen wird die jeweils auszugebende Zeichenkette gespeichert. */

		String theString;

		/** Zeichne Rahmen (Rechteck) um die ganze Tabelle */

		g.drawRect (xStart, yStart, xOffset * (tableSize+1), yOffset * (tableSize+1));

		/** Zeichne Rahmen (Rechteck) um den Tabelleninhalt ohne die x- und y-Achsenbeschriftung */

		g.drawRect (xStart + xOffset, yStart + yOffset, xOffset * tableSize, yOffset * tableSize);

		/** Iteriere ueber die Groesse der Tabelle in x-Richtung (horizontal) */

		for (int x = 0; x <= tableSize; x++) {

			/** Iteriere ueber die Groesse der Tabelle in y-Richtung (vertikal) */

			for (int y = 0; y <= tableSize; y++) {

				/** Beschriftung (Eingabegroessen) links (x==0) und oben (y==0) */

				if ((x == 0) ^ (y == 0))
					theString = "" + Math.max (x, y);

				/** wg. Kommutativitaet: nur Produkte OBERHALB der Hauptdiagonalen anzeigen */

				else if ((y <= x) && (x != 0))
					theString = "" + x * y;

				/** andernfalls wird nichts ausgegeben */

				else
					theString = "";

				/* Zeichenkette via drawString () schreiben, falls theString nichtleer */

				if (!theString.equals(""))
					g.drawString (theString, xStart + (x+1)*xOffset - numPadX, yStart + y*yOffset + numPadY);

			} // end for (y)

		} // end for (x)

	} // drawMatrix ()

	/** PUBLIC METHODS */

	/**
	  * paint () : paint-Methode von AWT.
	  *
	  * Ruft drawMatrix () mit den via Instanzvariable / Konstante festgelegten Eckdaten bzgl.
	  * Tabellengroesse und Abstand zum Rand (padding) auf.
	  *
	  * @return void
	  *
	  */

	public void paint (Graphics g) {

		/* Zeichne Multiplikationstabelle in das Fenster und beruecksichtige padding */

		drawMatrix (g, TABLE_SIZE, PADDING_X, PADDING_Y, getWidth () - PADDING_X, getHeight () - PADDING_Y);

	} // paint ()

} // Klasse Tabelle