package com.feeken.ritzel;

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

class KBlattRitzel {
	public int nZRitzel[];
	public int nZKBlatt[];
	public int xposKBlatt[];
	public int yposKBlatt[];
	public int xposRitzel[][];
	//public int yposRitzel[][];
	//public Color RitzelCol[]; 
    
	public int nRitzel;
	public int nKBlatt;

	KBlattRitzel() { // constructor fuer leeren Aufruf
		nZRitzel = new int[30];
		nZKBlatt = new int[10];
		xposKBlatt = new int[10];
		yposKBlatt = new int[10];
		xposRitzel = new int[10][30];
		//yposRitzel = new int[10][30];
        
		nRitzel = 0;
		nKBlatt = 0;
		for (int i = 0; i < 30; i++){
			nZRitzel[i] = 1000; 
			for (int j = 0; j < 10; j ++) {
			  xposRitzel[j][i] = 0;
			  //yposRitzel[j][i] = 0;
			}
		}
		for (int i = 0; i < 10; i++){
			nZKBlatt[i] = 1000;
			xposKBlatt[i] = 0;
			yposKBlatt[i] = 0;
		}
	}
    
	// Hinzufuegen eines Kettenblatts (hinten dran)
	public void AddKBlatt(int nZaehne) {
		nKBlatt = nKBlatt + 1;
	nZKBlatt[nKBlatt] = nZaehne;
	}
    
	//Hinzufuegen eines Ritzels (an der richtigen Stelle)
	public void AddRitzel(int nZaehne) {
		// wenn leer einfaches Setzen:
		if (nRitzel == 0) {
			nRitzel = 1;
			nZRitzel[1] = nZaehne;
		}
		// ansonsten alle weiteren nach hinten schieben
		// und einfügen 
		else if (!ExistRitzel(nZaehne)) {
			for (int i = 0; i < nRitzel+1; i++) {
				if (nZaehne < nZRitzel[i+1]) {
					for (int j = nRitzel+1; j > i; j--) {
						nZRitzel[j+1] = nZRitzel[j];
					}
				nZRitzel[i+1] = nZaehne;
				nRitzel = nRitzel +1;
				return;
				}
			}
	}
	}

	// Entfernen eines Ritzels
	public void RemoveRitzel(int nZaehne) {
		for (int i = 1; i < nRitzel + 1; i++) {
			if(nZRitzel[i]==nZaehne) {
				// Letztes Ritzel soll raus:
				if (i == nRitzel) {
					nZRitzel[i] = 1000;
					nRitzel = nRitzel - 1;
				}
				// Ritzel in Mitte der Liste: allen weiteren um
				// eins nach vorne schieben und letztes löschen 
				else {
					for ( int j = i; j < nRitzel; j++) {
						nZRitzel[j] = nZRitzel[j+1];
					}
					nZRitzel[nRitzel] = 1000;
					nRitzel = nRitzel -1;
					return;
				}
			}
		}
	}

	// Zuruecksetzen
	public void Clear() {
		nRitzel = 0;
		nKBlatt = 0;
		for (int i = 0; i < 30; i++){
			nZRitzel[i] = 1000; 
			for (int j = 0; j < 10; j ++) {
			  xposRitzel[j][i] = 0;
			  //yposRitzel[j][i] = 0;
			}
		}
		for (int i = 0; i < 10; i++){
			nZKBlatt[i] = 1000;
			xposKBlatt[i] = 0;
			yposKBlatt[i] = 0;
		}
	}
    
	public boolean ExistRitzel(int nZahl) {
		for (int i = 1; i < nRitzel+1; i++){
			if (nZahl == nZRitzel[i]) {
				return(true);
			}
		}
		return(false);
	}
    
	public int getIndex(int nZahl) {
		for (int i = 1; i < nRitzel+1; i++){
			if (nZahl == nZRitzel[i]) {
				return(i);
			}
		}
		return(0);
	}

	// Uebersetzung zwischen KBLatt i und Ritzel j
	public double uebers(int i, int j) {
		double us = new Integer(nZKBlatt[i]).doubleValue()/
		  new Integer(nZRitzel[j]).doubleValue();
		return(us);
	}

	// maximale Uebersetung des Sets
	public double maxUebers() {
		double maxUebers = 0.0;
		for (int i = 1; i < nKBlatt+1; i++) {
			for (int j = 1; j < nRitzel+1; j++) {
				double u = new Integer(nZKBlatt[i]).doubleValue()/
				  new Integer(nZRitzel[j]).doubleValue();
				if (u > maxUebers) { maxUebers = u ; } ;
			}
		}
		return(maxUebers);
	}

}



class Ritzelgrafik extends Panel 
				   implements MouseListener, MouseMotionListener  {

	public RitzelControls Controls;
	private KBlattRitzel m_KBRSet;     
	private double Faktor;
	private String sEinheit;
	public int breite;
	public int hoehe;
	static final int randx  = 20;
	static final int randy  = 45;
	static final int abst  = 30;
	boolean filled;
	boolean rePaintScales = true;
	int ilastbest = 0;
	int jlastbest = 0;
	int iSelected = 0;
	int jSelected = 0;

	Graphics g;

	public Ritzelgrafik() {
	addMouseListener(this);
		addMouseMotionListener(this);
	}


	public void SetKBlattRitzel(KBlattRitzel KBRSet) {
		m_KBRSet = KBRSet;
	}


	public void skala(Graphics gr,
			 int ix, int iy,
			 int breite, int hoehe,
			 double xmin, double xmax,
			 int ticabst, int tichoehe,
			 boolean zahlplot,
			 String einheit) {

		for (int i=ticabst; i< new Double(xmax).intValue()+1; i=i+ticabst) {
			double xtic = ix+breite*(new Integer(i).doubleValue()/xmax);
			int ixtic = new Double(xtic).intValue();
			int iytic = iy;
			gr.drawLine(ixtic, iytic, ixtic, iytic+tichoehe);   // tics
			if (zahlplot) {
				gr.drawString(new Integer(i).toString(),ixtic-5,iytic+20);
			}
		}
		if (zahlplot) {
		   gr.drawString(einheit,ix+3,iy+20);
		}
		gr.drawRect(ix,iy, breite, hoehe);
	}
    

	public void paint(Graphics gr) {
		// Rahmen zeichnen:
		g = gr;
		g.setFont(new Font ("Helvetica",Font.PLAIN, 10));
		g.setColor(Color.white);
		g.fillRect(randx,randy-25,breite-2*randx,(m_KBRSet.nKBlatt+1)*abst+50);
		g.setColor(Color.black);
		g.drawRect(randx,randy-25,breite-2*randx,(m_KBRSet.nKBlatt+1)*abst+50);
		for (int i=1; i<m_KBRSet.nRitzel+1;i++) {
			int istr = randx+(breite-2*randx-
			  30*(m_KBRSet.nRitzel-1))/2 + 30*(i-1);
		//g.drawString(new Integer(m_KBRSet.nZRitzel[i]).toString(),istr,randy-28);
		}

		// Skalen zeichnen:
        
		if( RitzelRechner.einheit == 0  ){
			Faktor = 3.6/60*RitzelRechner.trittfreq*RitzelRechner.umfang;
		sEinheit = "km/h";
		}
		else if(  RitzelRechner.einheit == 1 ){
		Faktor = 3.6/60./1.609*RitzelRechner.trittfreq*RitzelRechner.umfang;
		sEinheit = "mph";
		}
		else {
		Faktor = 0.001*RitzelRechner.umfang;
		sEinheit = "XXX";
		}
		skala(g, randx,randy+(m_KBRSet.nKBlatt+1)*abst,
		  breite-2*randx, 25,
		  0.0, m_KBRSet.maxUebers()*Faktor/0.9/1000,
		  10, 10, true, sEinheit);
		skala(g, randx,randy+(m_KBRSet.nKBlatt+1)*abst,
		  breite-2*randx, 25,
		  0.0, m_KBRSet.maxUebers()*Faktor/0.9/1000,
		  5, 8, false, sEinheit);
		skala(g, randx,randy+(m_KBRSet.nKBlatt+1)*abst,
		  breite-2*randx, 25,
		  0.0, m_KBRSet.maxUebers()*Faktor/0.9/1000,
		  1, 5, false, sEinheit);
		skala(g, randx,randy-25,
		  breite-2*randx, 25,
		  0.0, m_KBRSet.maxUebers()*RitzelRechner.umfang/0.9/1000,
		  2, 8, true, "Entfalt. m/U");
		skala(g, randx,randy-25,
		  breite-2*randx, 25,
		  0.0, m_KBRSet.maxUebers()*RitzelRechner.umfang/0.9/1000,
		  1, 5, false, "Entfalt. m/U");
          
		//g.setColor(Color.white);
		g.setColor(Color.gray);
		g.fillRect(randx+1,(m_KBRSet.nKBlatt+1)*abst+30,breite-2*randx-1,10);

		// Loop ueber Kettenblattanzahl:
		for (int i = 1; i < m_KBRSet.nKBlatt+1; i++) {
			// rote Linien fuer jedes KBlatt 
			g.setColor(Color.red);
			g.drawLine(randx,randy+abst*i,breite-randx,randy+abst*i);
			int pxZahl = breite-randx+3;
			int pyZahl = randy+abst*i+3;
			g.drawString(new Integer(m_KBRSet.nZKBlatt[i]).toString(),pxZahl,pyZahl);
			// KBlatt Aenderer
			int kxp[] = {pxZahl+5, pxZahl,pxZahl+10}; 
			int kyp1[] = {pyZahl+7, pyZahl+2, pyZahl+2}; 
			int kyp2[] = {pyZahl-15, pyZahl-10, pyZahl-10}; 
			g.fillPolygon(kxp,kyp1,3);
			g.fillPolygon(kxp,kyp2,3);
			g.drawPolygon(kxp,kyp1,3);
			g.drawPolygon(kxp,kyp2,3);
			// Position der Dreiecke fuer MouseClick-Vergleich
			m_KBRSet.xposKBlatt[i] = pxZahl + 5;
			m_KBRSet.yposKBlatt[i] = pyZahl - 4;
			// Loop ueber Ritzelanzahl und Dreiecke zeichnen:
			g.setColor(Color.black);
			for (int j=1; j < m_KBRSet.nRitzel+1; j++) {
				double x = randx + (breite-2*randx)*(0.9*m_KBRSet.uebers(i,j)/m_KBRSet.maxUebers());
				int ix = new Double(x).intValue();
				int iy = randy+abst*i;
				m_KBRSet.xposRitzel[i][j] = ix;
				//m_KBRSet.yposRitzel[i][j] = iy;
				int ixp[] = {ix,ix+6,ix-6};
				int iyp[] = {iy+6,iy-6,iy-6};
				double schraeglauf =  Math.abs( 1.5*(2*i - m_KBRSet.nKBlatt - 1) - 1*(m_KBRSet.nRitzel - 2*j + 1) );
				if (schraeglauf>8.5){g.setColor(Color.lightGray);}
				else if (schraeglauf>7.5) {
					g.setColor(Color.gray);
				}
				else if (schraeglauf>6.5) {
					g.setColor(Color.darkGray);
				}
				else {
					g.setColor(Color.black);
				}
				if (j == jSelected){
					g.setColor(Color.red);
				}
				//g.setColor(Color.black);
				g.fillPolygon(ixp,iyp,3);
				g.drawPolygon(ixp,iyp,3);
				if (schraeglauf <= 7.5) {
				if (j == jSelected){
					g.setColor(Color.red);
				}
				else {
					g.setColor(Color.white);
				}
					g.drawLine(ix,(m_KBRSet.nKBlatt+1)*abst+30,ix,(m_KBRSet.nKBlatt+1)*abst+40);
				}
				g.setColor(Color.gray);
				g.setFont(new Font ("Helvetica",Font.PLAIN, 9));
			g.drawString( new Integer(m_KBRSet.nZRitzel[j]).toString(),
		  ix-5,iy-7);
				g.setFont(new Font ("Helvetica",Font.PLAIN, 10));
			} //end Ritzelloop
		} //end Kettenblattloop

	} // end paint

	//Mouse event handling
	public void mouseClicked(MouseEvent e) {
	int x = e.getX();
	int y = e.getY();
	
	if (x < breite - randx) { //MouseClick fuer Ritzel-Aenderung
		// KettenblattIndex berechnen
		int iy = new Double(new Integer(y-randy).doubleValue()/abst + 0.5).intValue();
			// Ritzelzahnzahl berechnen
			double ueb = (new Integer(x-randx).doubleValue())/(breite-2*randx) /
			  0.9*m_KBRSet.maxUebers();
			int nZR = new Double(m_KBRSet.nZKBlatt[iy]/ueb + 0.5).intValue();
			if (nZR >= RitzelRechner.RZMIN & nZR <= RitzelRechner.RZMAX) {
				//System.out.println("Mouse clicked: " + new Integer(nZR).toString() + " " + new Boolean(m_KBRSet.ExistRitzel(nZR)).toString());
				if (!m_KBRSet.ExistRitzel(nZR)) {
					m_KBRSet.AddRitzel(nZR);
				}
				else {
					m_KBRSet.RemoveRitzel(nZR);
				}
				Controls.SetListBoxes();
				Controls.repaint();
				e.consume();
			repaint();
		}
		//for (int k=1;k<m_KBRSet.nRitzel+1;k++){
		//	System.out.println(Integer.toString(k) + " " + Integer.toString(m_KBRSet.nZRitzel[k]));
		//}
		}
		else { //MouseClick fuer KBlatt Aenderung
			for (int i=1; i < m_KBRSet.nKBlatt+1; i++) {
				int dy = y - m_KBRSet.yposKBlatt[i];
				if (dy > 5 & dy < 13) {
					System.out.println("down");
					m_KBRSet.nZKBlatt[i]=m_KBRSet.nZKBlatt[i]-1;
				}
				else if (dy < -5 & dy > -13) {
					System.out.println("up");
					m_KBRSet.nZKBlatt[i]=m_KBRSet.nZKBlatt[i]+1;
				}
			}
			Controls.SetListBoxes();
			Controls.repaint();
			e.consume();
		repaint();
		}
	}

	public void mousePressed(MouseEvent e) {
	int x = e.getX();
	int y = e.getY();
	int ix = 0;
	int iy = 0;
	int ibest = 0;
	int jbest = 0;
	
	for (int i = 1; i < m_KBRSet.nKBlatt+1; i++) {
		iy = m_KBRSet.yposKBlatt[i];
		for (int j = 1; j < m_KBRSet.nRitzel+1; j++) {
			ix = m_KBRSet.xposRitzel[i][j];
			if (Math.abs(iy-y) < 6 & Math.abs(ix-x) < 6 ) {
				ibest = i;
				jbest = j;
			} 	    
		}
	}
	
	if (ibest > 0 & (ibest != iSelected | jbest != jSelected)) {
		//System.out.println("best: " + Integer.toString(ibest) +"/"+ Integer.toString(jbest));
		iSelected = ibest;
		jSelected = jbest;
		repaint();
		}
	e.consume();
	}

	public void mouseReleased(MouseEvent e) {
		jSelected = 0;
	repaint();
			Controls.SetListBoxes();
			Controls.repaint();
	e.consume();
	}

	public void mouseEntered(MouseEvent e) {
	}

	public void mouseExited(MouseEvent e) {
	}

	public void mouseDragged(MouseEvent e) {
	int x = e.getX();
	int y = e.getY();
	
	if (x < breite - randx & jSelected > 0) { //MouseClick fuer Ritzel-Aenderung
		int nZRSel = m_KBRSet.nZRitzel[jSelected];
		// KettenblattIndex berechnen
		int iy = new Double(new Integer(y-randy).doubleValue()/abst + 0.5).intValue();
			// Ritzelzahnzahl berechnen
			double ueb = (new Integer(x-randx).doubleValue())/(breite-2*randx) /
			  0.9*m_KBRSet.maxUebers();
			int nZR = new Double(m_KBRSet.nZKBlatt[iy]/ueb + 0.5).intValue();
			if (nZR != m_KBRSet.nZRitzel[jSelected]){ 
				if (!m_KBRSet.ExistRitzel(nZR)) {
					m_KBRSet.AddRitzel(nZR);
					m_KBRSet.RemoveRitzel(nZRSel);
					jSelected = m_KBRSet.getIndex(nZR);
				repaint();
				}
		}
		}
	e.consume();
	}

	public void mouseMoved(MouseEvent e) {
	}

} //end class RitzelGrafik



class RitzelControls extends Panel 
					 implements ActionListener, ItemListener {
	// class Variables
	Ritzelgrafik grafik;
	public  KBlattRitzel KBRSet;
	public  java.awt.List lbKBlatt;
	public  java.awt.List lbRitzel;
	public  TextField TFumf;
	public  TextField TFfreq;
	public  Checkbox cbKmh;
	public  Checkbox cbMph;
	private Checkbox[] cb;

	public int graphwidth = 600;
	public int graphheight = 400;


	//Konstruktor mit Übergabe des Grafik Objekts
	public RitzelControls(Ritzelgrafik grafik,
						  KBlattRitzel KBRSet) {

	this.KBRSet = KBRSet;
	this.grafik = grafik;
	cb = new Checkbox[50];
	}
    
	public void SetListBoxes(){
		for (int j = 0; j<lbKBlatt.getItemCount(); j++) {
			lbKBlatt.deselect(j);
		}
		for (int i = 1; i<KBRSet.nKBlatt+1; i++) {
			lbKBlatt.select(KBRSet.nZKBlatt[i] - RitzelRechner.KBMIN);
		}
		for (int j = 0; j<lbRitzel.getItemCount(); j++) {
			lbRitzel.deselect(j);
		}
		for (int i = 1; i<KBRSet.nRitzel+1; i++) {
			lbRitzel.select(KBRSet.nZRitzel[i] - RitzelRechner.RZMIN);
		}
	}

	public void Build(){
	GridBagLayout p = new GridBagLayout();
	GridBagConstraints pc = new GridBagConstraints();
	//setFont(new Font ("Helvetica",Font.PLAIN, 10));
	setLayout (p);

	pc.gridheight = 1;    //  1 Feld hoch
		pc.gridwidth = 1;     //  1 Feld breit
		pc.fill = GridBagConstraints.NONE;
		pc.weightx= 1.0;
	addTextfeld("Kettenblattausw.:", p, pc);
	addTextfeld("Ritzelauswahl:", p, pc);
		pc.gridwidth = GridBagConstraints.REMAINDER;
	addTextfeld(" ", p, pc);
		pc.weightx= 0.0;     // reset

		pc.gridwidth = 1;     // Listen 1 Feld breit
	pc.gridheight = 3;    // Listen 4 Felder hoch
		pc.weighty= 0.0;     //

		// Liste der moeglichen Kettenblaetter erzeugen
		//p.add("Center",lbKBlatt = new List(7,true));
		lbKBlatt = new java.awt.List(7,true);
		p.setConstraints(lbKBlatt, pc);
		// EventHandler hinzufügen
	lbKBlatt.addItemListener(this);
		add(lbKBlatt);
		lbKBlatt.setBackground(Color.white);
		for (int i=RitzelRechner.KBMIN; i<RitzelRechner.KBMAX+1; i++) {
		   String kbzahl = Integer.toString(i);
		   lbKBlatt.add(kbzahl);
		}

		//Vorauswahl der Kettenblätter
		for (int i = 1; i<KBRSet.nKBlatt+1; i++) {
			lbKBlatt.select(KBRSet.nZKBlatt[i] - RitzelRechner.KBMIN);
		}

	// Liste der moeglichen Ritzel erzeugen
		lbRitzel = new java.awt.List(7,true);
		p.setConstraints(lbRitzel, pc);
		// EventHandler hinzufügen
	lbRitzel.addActionListener(this);
	lbRitzel.addItemListener(this);
		add(lbRitzel);
		lbRitzel.setBackground(Color.white);
	for (int i=RitzelRechner.RZMIN; i<RitzelRechner.RZMAX+1; i++) {
	   String rzzahl = Integer.toString(i);
	   lbRitzel.add(rzzahl);
		}
		//Vorauswahl der Ritzel
		for (int i = 1; i<KBRSet.nRitzel+1; i++) {
			lbRitzel.select(KBRSet.nZRitzel[i] - RitzelRechner.RZMIN);
		}

		pc.weighty= 0.0;
		pc.gridwidth = GridBagConstraints.RELATIVE;
	pc.gridheight = 1;    // Buttons 1 Feld hoch
	Label text = new Label("Radumfang[mm]:");
	p.setConstraints(text, pc);
	add(text);

	pc.gridwidth = GridBagConstraints.REMAINDER;
	TFumf   = new TextField(Integer.toString(RitzelRechner.umfang),4);
	TFumf.addActionListener(this);
	p.setConstraints(TFumf, pc);
	TFumf.setBackground(Color.white);
	add(TFumf);

	pc.gridwidth = GridBagConstraints.RELATIVE;
	Label lbFreq = new Label("Trittfrequenz[U/min]:");
	p.setConstraints(lbFreq, pc);
	add(lbFreq);

	pc.gridwidth = GridBagConstraints.REMAINDER;
	TFfreq  = new TextField(Integer.toString(RitzelRechner.trittfreq),4);
	TFfreq.addActionListener(this);
	p.setConstraints(TFfreq, pc);
	TFfreq.setBackground(Color.white);
	add(TFfreq);

	pc.gridwidth = 1;
	Label lbEinh = new Label("Geschw. in:");
	p.setConstraints(lbEinh, pc);
	add(lbEinh);

	pc.gridwidth = 1;
	CheckboxGroup group = new CheckboxGroup();
	cbKmh = new Checkbox("km/h", group, RitzelRechner.einheit == 0);
	p.setConstraints(cbKmh, pc);
	cbKmh.addItemListener(this);
	add(cbKmh);

	pc.gridwidth = GridBagConstraints.REMAINDER;
	cbMph = new Checkbox("mph", group, RitzelRechner.einheit == 1);
	p.setConstraints(cbMph, pc);
	cbMph.addItemListener(this);
	add(cbMph);

//--------------------------------------------------------
/*
pc.gridwidth = 1;
for (int j=0;j<4;j++){
for (int i=0;i<10;i++){
  cb[i+10*j] = new Checkbox( String.valueOf(i+10*j), true);
  p.setConstraints(cb[i+10*j], pc);
  //cbKmh.addItemListener(this);
  add(cb[i+10*j]);
  pc.gridwidth = 1;
}
pc.gridwidth = GridBagConstraints.REMAINDER;
}
*/

//--------------------------------------------------------
	pc.fill = GridBagConstraints.BOTH;
	pc.weighty= 10.0;
	}


	protected void addTextfeld(String name,GridBagLayout gridbag,
						   GridBagConstraints c) {
	Label text = new Label(name);
	gridbag.setConstraints(text,c);
	add(text);
	}


	// Neu Zeichnen
	public void NeuZeichnen() {
		//sCall =  sCall + "\n" + "startApp()";
	grafik.SetKBlattRitzel(KBRSet);
	//grafik.SetTrittFreq(Integer.parseInt(TFfreq.getText()));
	//grafik.SetUmfang(Integer.parseInt(TFumf.getText()));
	grafik.repaint();
	}


	// Event Handler
	public void actionPerformed(ActionEvent ev) {
	Object src = ev.getSource();

	if (src == lbRitzel) {
		System.out.println("Ritzel Event");
		}
	if (src == lbKBlatt) {
		System.out.println("KBlatt Event");
		}
	if (src == TFumf | src == TFfreq) {
		RitzelRechner.trittfreq = Integer.parseInt(TFfreq.getText());
		RitzelRechner.umfang = Integer.parseInt(TFumf.getText());
		NeuZeichnen();
		}

	String label = ev.getActionCommand();
	}

	public void itemStateChanged(ItemEvent ev) {
	Object src = ev.getSource();

		System.out.println("Controls Event");
	if (src == cbKmh | src == cbMph) {
		System.out.println("Einheit Event");
		if (cbKmh.getState()) { 
			RitzelRechner.einheit = 0;System.out.println("kmh");
		}
		if (cbMph.getState()) { 
			RitzelRechner.einheit = 1;System.out.println("mph");
		}
		NeuZeichnen();
		}
	if (src == lbRitzel) {
		System.out.println("Ritzel Item Event");
		KBRSet.Clear();
		for (int k=0; k<lbKBlatt.getSelectedIndexes().length; k++) {
			KBRSet.AddKBlatt(lbKBlatt.getSelectedIndexes()[k]+RitzelRechner.KBMIN);
		}
		for (int r=0; r<lbRitzel.getSelectedIndexes().length; r++) {
		   KBRSet.AddRitzel(lbRitzel.getSelectedIndexes()[r]+RitzelRechner.RZMIN);
		}
		NeuZeichnen();
		}
	if (src == lbKBlatt) {
			KBRSet.Clear();
		for (int k=0; k<lbKBlatt.getSelectedIndexes().length; k++) {
			KBRSet.AddKBlatt(lbKBlatt.getSelectedIndexes()[k]+RitzelRechner.KBMIN);
		}
		for (int r=0; r<lbRitzel.getSelectedIndexes().length; r++) {
			KBRSet.AddRitzel(lbRitzel.getSelectedIndexes()[r]+RitzelRechner.RZMIN);
		}
		System.out.println("KBlatt Item Event");
		NeuZeichnen();
		}

	}

 } // end RitzelControls



public class RitzelRechner extends Applet {

	Ritzelgrafik grafik;
	RitzelControls controls;
	KBlattRitzel KBRSet;
    
	public static int umfang = 2200;
	public static int einheit = 0;
	public static int trittfreq = 100;
	public static int graphwidth = 600;
	public static int graphheight = 400;
    
	private String KBlatt = "39,53";
	private String Ritzel = "12,13,14,15,17,19,21,23";
	//private StringBuffer KBlatt;
	//private StringBuffer Ritzel;

	public static  int KBMAX = 64;
	public static  int KBMIN = 20;
	public static  int RZMIN = 10;
	public static  int RZMAX = 35;
	
	//public static String sTest = "x";
	//public static String sCall = "xxx";
	
	public static boolean noParams = true;
    
	static boolean  modeApplet = true;

    
	public void destroy() {
		System.out.println("End");
		remove(grafik);
		remove(controls);
	}

	public static void main(String args[]) {
		//sCall = sCall + "\n" + "main()";
		
		modeApplet = false;
	Frame f = new Frame("RitzelRechner");
	RitzelRechner ritzelRechner = new RitzelRechner();
	ritzelRechner.init();
	ritzelRechner.start();

	f.add("Center", ritzelRechner);
	f.setSize(graphwidth+50, graphheight+50);
	f.show();
	}

	public String getAppletInfo() {
		return "Simple Applet!";
/*		return "Params:" + sTest + "\n" +
		       "KBlatt:" + KBlatt + "\n" +
		       "Ritzel:" + Ritzel + "\n" +
		       "lastCall" +sCall; */
	}
	public void init() {
		//sCall =  sCall + "\n\n" + "init()";


		// Get Applet parameters from HTML <param...> tags
		if (modeApplet) {
			graphwidth = Integer.parseInt(getParameter("graphwidth"));
			graphheight = Integer.parseInt(getParameter("graphheight"));
			KBMIN = Integer.parseInt(getParameter("KBMIN"));
			KBMAX = Integer.parseInt(getParameter("KBMAX"));
			RZMIN = Integer.parseInt(getParameter("RZMIN"));
			RZMAX = Integer.parseInt(getParameter("RZMAX"));
			umfang = Integer.parseInt(getParameter("umfang"));
			trittfreq = Integer.parseInt(getParameter("freq"));
			einheit = Integer.parseInt(getParameter("Einheit"));
			
			if (noParams){
				//KBlatt = new StringBuffer("61,62,63");
				//Ritzel = new StringBuffer("10,11,12,13");
				//Lese Kettenblaetter String: "22,32,..."
				KBlatt = getParameter("KBlatt");
				//Lese Ritzel String: "11,13,15,..."
				Ritzel = getParameter("Ritzel");	
			}

		}
		
		/*try{
			String query = getDocumentBase().getQuery().toUpperCase();
			if (query.startsWith("KB")){
				setParams(query);
			}
		}catch(Exception ex){
		}*/
	}
	
	public void start(){
		//sCall =  sCall + "\n" + "start()";
		
		startApp();
	}
	
	public void startApp(){
	//sCall =  sCall + "\n" + "startApp()";

		//Kettenblatt-Ritzel Kombination Füllen
	KBRSet = new KBlattRitzel();
	KBRSet.Clear();
	for (StringTokenizer t = new StringTokenizer(KBlatt.toString(), ",") ; t.hasMoreTokens() ; ) {
		String str = t.nextToken();
			KBRSet.AddKBlatt(Integer.parseInt(str));
		}
	for (StringTokenizer t = new StringTokenizer(Ritzel.toString(), ",") ; t.hasMoreTokens() ; ) {
		String str = t.nextToken();
			KBRSet.AddRitzel(Integer.parseInt(str));
		}

	setLayout(new BorderLayout());
	grafik = new Ritzelgrafik();
	grafik.breite = graphwidth;
	grafik.hoehe = graphheight;
	grafik.SetKBlattRitzel(KBRSet);
	controls = new RitzelControls(grafik,KBRSet);
	grafik.Controls = controls;
	controls.Build();
	//controls.KBRSet = KBRSet;
	add("North", controls);
	add("Center", grafik);
	
	//setParams("?KB=31,41,51&RZ=12,13,14,15,17,19,21,24,28");
	//setParams("?KB=31,41,51&RZ=10/12-25");
	}

	public void setParams(String params){

		//sCall =  sCall + "\n" + "setParams(" + params +")";
		if (params.startsWith("?")){
			params = params.substring(1);
		}

		for (StringTokenizer t = new StringTokenizer(params, "&") ; t.hasMoreTokens() ; ) {
			String str = t.nextToken();
			if (str.startsWith("KB")){
				KBlatt = str.substring(3);
				//sCall =  sCall + "\n" + "  KBlatt:" + KBlatt;
			}
			if (str.startsWith("RZ")){
				Ritzel = str.substring(3);
				if (Ritzel.indexOf("/") > 0){
					Ritzel = getParameter(Ritzel);
				}
			}
		}
		
		KBRSet = new KBlattRitzel();
		KBRSet.Clear();
		for (StringTokenizer t = new StringTokenizer(KBlatt, ",") ; t.hasMoreTokens() ; ) {
			String str = t.nextToken();
				KBRSet.AddKBlatt(Integer.parseInt(str));
			}
		for (StringTokenizer t = new StringTokenizer(Ritzel, ",") ; t.hasMoreTokens() ; ) {
			String str = t.nextToken();
				KBRSet.AddRitzel(Integer.parseInt(str));
			}
		controls.KBRSet = KBRSet;
		controls.NeuZeichnen();
	}

/*	protected void addTextfeld(String name,GridBagLayout gridbag,
						   GridBagConstraints c) {
		Label text = new Label(name);
		gridbag.setConstraints(text,c);
		add(text);
	}
*/

 } // end Ritzelrechner