// Thoms Dorn
// Ethernet Visualisierung
// WS 1996/97
// E881 8625093


//+ "Folding Information"
//  For all, who have an editor, which is able to fold: my folding-keys are //+ and //-
//-

import java.applet.*;
import java.awt.*;
import java.lang.Math;
import java.util.Random;
import java.lang.*;

import java.awt.Graphics;
import java.util.Date;


interface Const{
  public static final int  MAXPC = 6;    // Max-PC = 8
  public static final byte T = 0;        // T-Wedge
  public static final byte C = 1;        // Cable -
  public static final byte L = 2;        // Terminator, End Left
  public static final byte R = 3;        // Terminator, End Right
  public static final int  WHITE = 9;    // Weisse Farbe   (Leeres Kabel)
  public static final int  BLACK = 0;    // Schwarze Farbe (Jam)
  public static final int  TWOCOL = 10;  // Grau

  public static final int  MAXSLICE = 10;  // Maximale Pakete
  public static final int  MINSIZE  = MAXPC*3+4;  // Minimale Paketlänge
  public static final int  BIGSIZE  = (MAXPC*3+4)*2;  // Große Paketlänge
  public static final int  SLOW = 1000;  // For speed
  public static final int  MED  = 500;
  public static final int  FAST = 30;


  // colortable 6 PCs with its colors (0, 1-8, 9)
  public static final Color pc_col[]={Color.black, Color.blue,Color.cyan,Color.green,Color.magenta,Color.orange,Color.pink, Color.red, Color.yellow, Color.white, Color.gray};
}


public class Ether extends Applet implements Runnable
{
  static final String message = "Thomas Dorn (tdorn@vip.at)";
  int speed = Const.SLOW;

  int gh = 0;        // Height for JavaApplikat!
  int zaehler=0;                // For statistics
  int slice = 0;    // Time-Slice from 0 to max_slice;

  boolean autoplay = true;   // else single-step
  boolean forward  = true;   // else backward

  // Variables for memory (ff/bw)
  int packetI[][] = new int [Const.MAXSLICE][Const.MAXPC];
  int   destI[][] = new int [Const.MAXSLICE][Const.MAXPC];

  Thread animThread = null;


//+ "Initialisierung der Buttons, Labels und Panels"

  // Needed Buttons
  Button b_stepB;
  Button f_stepB;

  Button b_playB;
  Button f_playB;

  Button stopB;
  Button newB;

  Choice speedB;

  Choice packetB[][] = new Choice [Const.MAXSLICE][Const.MAXPC];
  Choice destB[][]   = new Choice [Const.MAXSLICE][Const.MAXPC];
  Checkbox connectB[]  = new Checkbox [Const.MAXPC];


  // Needed Labels

  Label overL;
  Label timeL;
  Label sliceL;
  Label stepL;
  Label playL;
  Label speedL;

  Label statusL[] = new Label[Const.MAXPC];

  // Panels

  Panel mainP;
  Panel motionP;
  Panel dataP;
  Panel barsP;
  Panel timeP;
  Panel stepP;
  Panel playP;
  Panel speedP;
  Panel spcP[] = new Panel[Const.MAXPC];
  Panel hpcP[] = new Panel[Const.MAXPC];
  Panel pcP[] =  new Panel[Const.MAXPC];
  Panel progP[] = new Panel[Const.MAXPC];

  Panel hstepP;
  Panel hplayP;

  barCanvas progC[] = new barCanvas[Const.MAXPC];


  Panel animP;
  pipeCanvas pipeC[] = new pipeCanvas[4+(Const.MAXPC*3)];    // for the animation: a cable 0 and 21 are terminators ...

  nrCanvas nrC[] = new nrCanvas[2];
  Panel nrP;
//-
  // First Initialization (init Data)
  public void init()
  {
    //+ "   Buttons"
    System.out.println("Making a nice Layout ...");

    setLayout(new BorderLayout());            // Initialize the global Layout
    overL = new Label("Ethernetvisualisierung", Label.CENTER);
    add("North",overL);

    // Make the Label of Motion Panel
    timeL  = new Label("Time Slice", Label.CENTER);
    sliceL = new Label("0:0", Label.CENTER);
    stepL  = new Label("Step", Label.CENTER);
    playL  = new Label("Play", Label.CENTER);
    speedL = new Label("Speed", Label.CENTER);


    // Make the Buttons of Motion Panel
    b_stepB = new Button("<");
    f_stepB = new Button(">");

    b_playB = new Button("<");
    f_playB = new Button(">");

    stopB   = new Button("Stop");
    newB    = new Button("New");

    speedB  = new Choice();
    speedB.addItem("slow");
    speedB.addItem("medium");
    speedB.addItem("high");
    //-
//+ "  Motion Panel"
    // ###############  motion Panel  ######################################

    motionP = new Panel();
    motionP.setLayout(new FlowLayout());     // Motion-Panel

    timeP = new Panel();
    timeP.setLayout(new BorderLayout());     // Time-Panel

    hstepP = new Panel();
    hstepP.setLayout(new FlowLayout());     // Step-Panel  Help

    hplayP = new Panel();
    hplayP.setLayout(new FlowLayout());     // Play-Panel  Help

    stepP = new Panel();
    stepP.setLayout(new BorderLayout());     // Step-Panel

    playP = new Panel();
    playP.setLayout(new BorderLayout());     // Play-Panel

    speedP = new Panel();
    speedP.setLayout(new BorderLayout());     // Speed-Panel


    timeP.add ("North", timeL);
    timeP.add ("South", sliceL);


    hstepP.add (b_stepB);
    hstepP.add (f_stepB);
    stepP.add ("North", stepL);
    stepP.add ("South", hstepP);

    hplayP.add (b_playB);
    hplayP.add (f_playB);
    hplayP.add (stopB);
    hplayP.add (newB);

    playP.add ("North", playL);
    playP.add ("South", hplayP);

    speedP.add ("North", speedL);
    speedP.add ("South", speedB);

    motionP.add(timeP);
    motionP.add(stepP);
    motionP.add(playP);
    motionP.add(speedP);

//-
//+ "  Data Panel (PCs)"
    // ############### Data Panel #########################################
    dataP = new Panel();
    dataP.setLayout(new GridLayout(1,Const.MAXPC));     // Data-Panel


    for (int i=0;i<Const.MAXPC;i++)
    {
      pcP[i] = new Panel();
      pcP[i].setLayout(new BorderLayout());     // PC-Panel (Packet/dest, Connect)

      hpcP[i] = new Panel();
      hpcP[i].setLayout(new GridLayout(Const.MAXSLICE,2));     // PC-Panel packt+dest

      spcP[i] = new Panel();
      spcP[i].setLayout(new BorderLayout());     // PC-Panel Connect, Status, Bars
    }

    // ############### Data Buttons #########################################
    for (int i=0;i<Const.MAXPC;i++)
    {
      connectB[i] = new Checkbox("Connect");
      connectB[i].setState(true);
      statusL[i] = new Label("Status", Label.CENTER);
      for (int j=0;j<Const.MAXSLICE;j++)
      {
	packetB[j][i] = new Choice();
	packetB[j][i].addItem("No");
	packetB[j][i].addItem("Small");
	packetB[j][i].addItem("Large");
	destB[j][i] = new Choice();
	for (int k=1;k<=Const.MAXPC;k++)
	  destB[j][i].addItem("D"+k);
      }
    }

//-
    makeRandom();
//+ "  Bar-Panel, binding PCs"
    // ############### Data Bindings for Bars #########################################

    nrC[0] = new nrCanvas();
    nrC[1] = new nrCanvas();

    for (int i=0;i<Const.MAXPC;i++)
    {
      for (int j=0;j<Const.MAXSLICE;j++)
      {
	hpcP[i].add(packetB[j][i]);
	hpcP[i].add(destB[j][i]);
      }

      progC[i] = new barCanvas(0,0,0, i+1);

      spcP[i].add("North", connectB[i]);
      spcP[i].add("Center",statusL[i]);
      spcP[i].add("South", progC[i]);

      pcP[i].add("North",hpcP[i]);
      pcP[i].add("South",spcP[i]);

      dataP.add(pcP[i]);
    }

    // dataP - Panel um Zahlen links und rechts erweitern
    nrP = new Panel();
    nrP.setLayout(new BorderLayout());     // Data-Panel mit Zahlenreihe

    nrP.add("West",nrC[0]);
    nrP.add("Center",dataP);
    nrP.add("East",nrC[1]);

//-
//+ "  Building the Cable"
    // ############### Paint the nice Cable ... #########################################

    // System.out.println("Generating Cable");

    animP = new Panel();
    animP.setLayout(new GridLayout(1,4+(Const.MAXPC*3)));     // Anim-Panel

    pipeC[0] = new pipeCanvas(Const.L,0,Const.WHITE);
    pipeC[1] = new pipeCanvas(Const.C,1,Const.WHITE);
    for (int i=0;i<Const.MAXPC;i++)
    {
      pipeC[i*3+2] = new pipeCanvas(Const.C,i*3+2,Const.WHITE);
      pipeC[i*3+3] = new pipeCanvas(Const.T,i*3+3,i+1);       // Farbe des PCs
      pipeC[i*3+4] = new pipeCanvas(Const.C,i*3+4,Const.WHITE);
    }
    pipeC[Const.MAXPC*3+2] = new pipeCanvas(Const.C,Const.MAXPC*3+2,Const.WHITE);
    pipeC[Const.MAXPC*3+3] = new pipeCanvas(Const.R,Const.MAXPC*3+3,Const.WHITE);

    for (int i=0;i<(4+Const.MAXPC*3);i++)
      animP.add(pipeC[i]);

//-

    mainP = new Panel();
    mainP.setLayout(new FlowLayout());     // Main-Panel



    // ############### binding with Main-Panel ################################
    // System.out.println("Binding Main Panel ...");
    mainP.add(motionP);
    mainP.add(nrP);
    mainP.add(animP);
    add("Center", mainP);

    // System.out.println("Go on ...");

  }

//+    "public void makeRandom()"
    public void makeRandom()
    {
    Random zufall= new Random();
    int x;

    // System.out.println("Generating Random-Packages");
    for (int i=0;i<Const.MAXPC;i++)
    {
      for (int j=0;j<Const.MAXSLICE;j++)
      {
	x = (Math.abs(zufall.nextInt())%(Const.MAXPC*2));
	if (x == 0)
	{
	  packetB[j][i].select("Small");
	  packetI[j][i] = 1;
	}
	else if (x == 1)
	{
	  packetB[j][i].select("Large");
	  packetI[j][i] = 2;
	}
	else
	{
	  packetB[j][i].select("No");
	  packetI[j][i] = 0;
	}

	// System.out.println("Zufallszahl: "+ x);

	destB[j][i].select("D1");
	destI[j][i] = 1;
      }
    }

    for (int i=0;i<Const.MAXPC;i++)
    {
      for (int j=0;j<Const.MAXSLICE;j++)
      {
	if (packetI[j][i] != 0)
	{
	  int h;
	  x = (Math.abs(zufall.nextInt())%(Const.MAXPC*2));
	  h = (x+1)/2;
	  if (h == (i+1) )       // Eigene PC!
	  {
	    if ( (h+1) < Const.MAXPC )
	      h++;
	    else
	      h--;
	  }
	  destB[j][i].select("D"+h);
	  destI[j][i] = h;
	}
      }
    }

    // Wegen Disconnect wieder ausschalten ... bisschen dumm, nicht?
    for (int i=0;i<Const.MAXPC;i++)
    {
      if (connectB[i].getState() == false)
      {
	for (int j=0;j<Const.MAXSLICE;j++)
	{
	  packetB[j][i].select("No");
	  packetI[j][i] = 0;
	}
      }
    }

    }
//-
//+  "  public void run()       // Kabel bunt anpinseln  "
    public void run()       // Kabel bunt anpinseln
    {

      if (Thread.currentThread() == animThread)
      {
	boolean j = true;
	int richtung[] = new int[Const.MINSIZE];   // 0 = keine R, 1 = Links, 2=rects, 3=beide
	int richtungN[] = new int[Const.MINSIZE];   // 0 = keine R, 1 = Links, 2=rects, 3=beide

	int rounds;

	if (autoplay == true)
	  rounds = Const.MAXSLICE;
	else
	  rounds = 1;

	for (int jj=0;jj<rounds;jj++)
	{

	// Initialisierung der Pakete
	for (int i=0;i<Const.MINSIZE;i++)         // Anzahl der Kabel-Stücke
	  richtung[i] = 0;

	for (int i=0;i<Const.MAXPC;i++)            // Anzahl der T-Stücke
	{
	  if (packetI[slice][i] > 0)
	  {
	    j = true;
	    if (packetI[slice][i] == 1)  // Kleines Paket
	      pipeC[i*3+3].inject(Const.MINSIZE);
	    else                                            // Großes Paket
	      pipeC[i*3+3].inject(Const.BIGSIZE);
	  }
	}

	nrC[0].setH(gh);
	nrC[1].setH(gh);
	nrC[0].setAct(slice);
	nrC[1].setAct(slice);

	// Solange, bis kein Paket und nichts auf der Leitung
	while (j)
	{
	  int k=0;
	  boolean test = true;

	  zaehler ++;
	  sliceL.setText(slice+":"+zaehler);
	  // System.out.print("*");
	  while (k<Const.MAXPC)                 // Test, ob noch was zu senden da ist
	  {
	    if ( (pipeC[k*3+3].getInject() > 0) || (pipeC[k*3+3].getWait() > 0) )
	    {
	      k = Const.MAXPC;
	      test = true;
	    }
	    else
	    {
	      k++;
	      test = false;
	    }
	  }
	  if (test == false)                    // Nur, wenn sonst nichts mehr da ist
	  {
	    int a = 0;
	    for (int i=0;i<Const.MINSIZE;i++)         // Anzahl der Kabel-Stücke
	      a = a + richtung[i];
	    if (a > 0)                          // Es ist noch was am Kabel
	      test = true;
	  }

	  j = test;

	  // Kabel durchchecken
	  pipeC[0].setColor(pipeC[1].getColor());      // Left Terminator eats Pakets
	  richtungN[0] = richtung[1];                // Left Terminator eats Pakets
	  for (int i=1; i < Const.MINSIZE-1; i++)    // Maximum Cable peaces
	  {
	    if (( (richtung[i-1] == 1) || (richtung[i-1] == 0) ) && ((richtung[i+1] == 2) || (richtung[i+1] == 0) ) )
	    {                                      // Zeigt auseinander
	      pipeC[i].setColor(Const.WHITE);
	      richtungN[i] = 0;
	    }
	    else if (((richtung[i-1] == 1) || (richtung[i-1] == 0) ) && ( (richtung[i+1] == 1) || (richtung[i+1] == 3))  )     // Get Color from Right neighbour
	    {
	      pipeC[i].setColor(pipeC[i+1].getColor());
	      richtungN[i] = 1;
	    }

	    else if (((richtung[i-1] == 2) || (richtung[i-1] == 3))  && ((richtung[i+1] == 2) || (richtung[i+1] == 0))  )     // Get Color from Left neighbour
	    {
	      pipeC[i].setColor(pipeC[i-1].getColor());
	      richtungN[i] = 2;
	    }
	    else if (((richtung[i-1] == 2) || (richtung[i-1] == 3))  && ((richtung[i+1] == 1) || (richtung[i+1] == 3) ))     // Collision
	    {
	      pipeC[i].setColor(Const.BLACK);
	      richtungN[i] = 3;                                      // In both directions
	    }
	    else
	    {
	      System.out.println("Impossible State. Please tell tdorn@vip.at that this happens!");
	    }

	  }
	  pipeC[Const.MINSIZE-1].setColor(pipeC[Const.MINSIZE-2].getColor());      // rechter Terminator frißt Pakete
	  richtungN[Const.MINSIZE-1] = richtung[Const.MINSIZE-2];                // rechter Terminator frißt Pakete

	  for (int i=0; i < Const.MAXPC; i++)         // Maximum  T-Peaces
	  {
	    progC[i].setZaehler(zaehler);
	    statusL[i].setText("Listening");
	    pipeC[i*3+3].decWait();                   // Dec Waiting-time for sending

	    if ( (pipeC[i*3+3].getInject() > 0) && (pipeC[i*3+3].getWait() == 0) )   // ready for sending
	    {
	      if (pipeC[i*3+3].getInject() == pipeC[i*3+3].getOInject())             // Nothing sent befor
	      {
		if (richtungN[i*3+3] == 0)                       // Free Cell, start sending
		{
		  pipeC[i*3+3].setColor(pipeC[i*3+3].getOColor());
		  richtungN[i*3+3] = 3;
		  pipeC[i*3+3].decInject();
		  statusL[i].setText("Sending");
		  progC[i].setTransmit();
		}
		else                 // I have to wait till cable is free
		{
		}

	      }
	      else                                               // sending in progress
	      {
		if (richtungN[i*3+3] == 0)                       // Free Cell, sending
		{
		  pipeC[i*3+3].setColor(pipeC[i*3+3].getOColor());
		  richtungN[i*3+3] = 3;
		  pipeC[i*3+3].decInject();
		  statusL[i].setText("Sending");
		  progC[i].setTransmit();
		}
		else                 // Collision!
		{
		  pipeC[i*3+3].inject(pipeC[i*3+3].getOInject());  // wieder alte Paketanzahl

		  Random zufall = new Random();                      // Wartezeit für nächsten Versuch
		  pipeC[i*3+3].setWait( (Math.abs(zufall.nextInt())%6 * Const.MINSIZE));
		  System.out.println("Collision Dedect: Wait "+pipeC[i*3+3].getWait() );
		  statusL[i].setText("Collision");
		  progC[i].setCollision();
		}

	      }
	    }
	    else                            // Nothing to send, maybe something for receiving
	    {
	      if ( (pipeC[i*3+3].getColor() < Const.WHITE) &&
		   (pipeC[i*3+3].getColor() > Const.BLACK) )
	      {
		// System.out.println("R i="+(i+1)+" slice="+ slice + "Color="+pipeC[i*3+3].getColor() + ":="+destI[slice][pipeC[i*3+3].getColor()-1] );
		if ( (i+1) == destI[slice][pipeC[i*3+3].getColor()-1] )
		{
		  statusL[i].setText("Receiving");
		  progC[i].setReceive();
		}
	      }
	    }
	  }

	  for (int i=0; i < Const.MINSIZE; i++)       // update whole Cable
	  {
	    richtung[i] = richtungN[i];               // update direction
	    pipeC[i].update();
	  }

	  try                                     // Wait a little bit
	  {
	    Thread.sleep(speed);
	  }
	  catch (InterruptedException e){};
	}


	  if (autoplay == true)
	  {
	    if (forward == true)
	    {
	      slice ++;
	      if (slice >= Const.MAXSLICE)
		slice = 0;
	    }
	    else
	    {
	      slice --;
	      if (slice < 0)
		slice = Const.MAXSLICE-1;
	    }

	  }
	}
	animThread = null;
	System.out.println("Thread fertig");

	}

    }
//-
//+ "   public boolean action(Event ev, Object arg) "
    public boolean action(Event ev, Object arg)
    {
      // System.out.println("Hab was "+ (String)arg);
      if (ev.id == Event.WINDOW_DESTROY)             // Fenster sollte zu machen
      {
	  System.exit(0);
      }

      if (ev.target instanceof Button) // Is a Button
      {
	if (ev.target == stopB)        // Stop
	{
	  if (animThread != null)
	    animThread.stop();
	  animThread = null;

	}
	else if (ev.target == newB)              // New
	{
	  zaehler = 0;
	  slice = 0;
	  sliceL.setText(slice+":"+zaehler);
	  for (int i=0;i<Const.MAXPC;i++)        // Bars
	    progC[i].setNew();
	  makeRandom();
	  for (int i=0;i<Const.MINSIZE;i++)      // Cabel
	  {
	    pipeC[i].redraw(Const.WHITE);
	    pipeC[i].inject(0);
	    pipeC[i].setWait(0);
	  }
	}

	else if (ev.target == b_playB)      // Backward-Play
	{
	  autoplay = true;
	  forward = false;


	  animThread = new Thread(this, "Anim-Thread");
	  animThread.start();

	}

	else if (ev.target == f_playB)      // Forward-Play
	{
	  autoplay = true;
	  forward = true;

	  animThread = new Thread(this, "Anim-Thread");
	  animThread.start();
	}
	else if (ev.target == b_stepB)      // Step Back
	{
	  autoplay = false;
	  forward = false;
	  slice --;
	  if (slice < 0)
	    slice = Const.MAXSLICE-1;

	  sliceL.setText(slice+":"+zaehler);
	  animThread = new Thread(this, "Anim-Thread");
	  animThread.start();

	}
	else if (ev.target == f_stepB)      // Step Fw
	{
	  autoplay = false;
	  forward = true;
	  slice ++;
	  if (slice >= Const.MAXSLICE)
	    slice = 0;
	  sliceL.setText(slice+":"+zaehler);

	  animThread = new Thread(this, "Anim-Thread");
	  animThread.start();
	}
	else
	  System.out.println("Unknown Button "+ (String)arg);
	return true;
      }
      if (ev.target instanceof Choice) // Is Choice
      {
	String label = (String)arg;   // Contents of Result

	if (ev.target == speedB)      // Speed-Choice
	{
	  if (label.equals("slow"))
	    speed = Const.SLOW;
	  else if (label.equals("medium"))
	    speed = Const.MED;
	  else
	    speed = Const.FAST;
	  // System.out.println("New Speed: "+speed);
	}
	else    // Ich geh mal davon aus, dass es einer meiner Choices ist!
	{
	  // System.out.println("New Choice");
	  for (int i=0;i<Const.MAXPC;i++)      // Alle Gadget-Daten übernehmen
	  {
	    for (int j=0;j<Const.MAXSLICE;j++)
	    {
	      packetI[j][i] = packetB[j][i].getSelectedIndex() ;
	      destI[j][i]   = destB[j][i].getSelectedIndex() + 1;
	    }
	  }

	}
	return true;
      }
      if (ev.target instanceof Checkbox)  // Can only be the Connect-Button
      {
	int i;
	for (i=0;i<Const.MAXPC;i++)   // Which Connect Button?
	{
	  if (ev.target == connectB[i])
	    break;
	}
	// System.out.println("Button "+ i);
	if (connectB[i].getState() == false)
	{
	  for (int j=0;j<Const.MAXSLICE;j++)
	    packetI[j][i] = 0;
	}
	else
	{
	  for (int j=0;j<Const.MAXSLICE;j++)
	    packetI[j][i] = packetB[j][i].getSelectedIndex();
	}
      }

      return false;             // No Event for me ...
    }                           // End action
//-
  public void uff()
  {
    gh = 0;
  }
  //+ " public static void main(String args[])"
  public static void main(String args[])
  {
	System.out.println("Ethernetvisualisierung");
	Frame f = new Frame("Ethernetvisualisierung");
	Ether applet = new Ether();
	applet.init();
	applet.start();
	f.add("Center", applet);
	f.resize(100*Const.MAXPC+300,600);
	f.show();
	System.out.println("Please give your commands ...");

	applet.uff();

  }
  //-
}

//+ "class barCanvas extends Canvas"
class barCanvas extends Canvas
{
    int tra;
    int rec;
    int col;
    int pc;
    int t,r,c;
    int zaehler;

    public barCanvas(int tra, int rec, int col, int pc)
    {
      this.tra = tra;
      this.rec = rec;
      this.col = col;
      this.pc  = pc;
      this.zaehler=0;
    }

    public void paint(Graphics g)
    {
	int w = size().width;
	int h = size().height;

	g.setColor(Const.pc_col[pc]);
	g.drawRect(0, 0, w - 1, h - 1);
	g.drawRect(1, 1, w - 3, h - 3);

	g.setColor(Color.lightGray);
	g.fillRect(2,2,w-5,h-5);

	g.setColor(Color.white);
	g.drawLine(w-3,2,w-3,h-3);
	g.drawLine(2,h-3,w-3,h-3);

	g.setColor(Color.darkGray);
	g.drawLine(2,2,w-2,2);
	g.drawLine(2,2,2,h-2);

	g.setColor(Color.black);
	g.drawString("Auslastung", (w - g.getFontMetrics().stringWidth("Auslastung"))/2,12);
	g.setFont(new Font("Helvetica", Font.PLAIN, 8));

	g.drawString("T", 4, 24);
	g.drawString("R", 4, 34);
	g.drawString("C", 4, 44);

	myPaint();

   }

    public void myPaint()
    {
      Graphics g = getGraphics();

	g.setColor(Color.lightGray);
	g.fillRect(15,15,100,30);

	g.setColor(Color.yellow);
	g.fillRect(15,15,tra,10);
	g.setColor(Color.green);
	g.fillRect(15,25,rec,10);
	g.setColor(Color.red);
	g.fillRect(15,35,col,10);
    }

    public void setNew()
    {
      // System.out.println("Auswertung barCanvas. t="+t+" tra="+tra+" z="+zaehler);
      // System.out.println("Auswertung barCanvas. r="+r+" rec="+rec+" z="+zaehler);
      this.tra = 0;
      this.rec = 0;
      this.col = 0;
      this.t = 0;
      this.r = 0;
      this.c = 0;
      repaint();
    }
    public void setTransmit()
    {
      this.t ++;
      this.tra = (100*this.t)/this.zaehler;
      // System.out.println("setTra  t="+t+" tra="+tra+" z="+zaehler);
      myPaint();
    }
    public void setReceive()
    {
      this.r ++;
      this.rec = (100*this.r)/this.zaehler;
      myPaint();
    }
    public void setCollision()
    {
      this.c ++;
      this.col = (100*this.c)/this.zaehler;
      myPaint();
    }
    public void setZaehler(int z)
    {
      this.zaehler = z;
      this.tra = (100*this.t)/this.zaehler;
      this.rec = (100*this.r)/this.zaehler;
      this.col = (100*this.c)/this.zaehler;
      myPaint();
    }
    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension minimumSize()
    {
	return new Dimension(100,50);
    }

    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension preferredSize()
    {
	return minimumSize();
    }
}
//-
//+ "class pipeCanvas extends Canvas"
class pipeCanvas extends Canvas
{
    byte what;     // Terminator, T-Wedge, Cable (E, T, -)  E--T--T--T--T--T--T--E
    int pos;       // 22 positions (2 terminators, 6-Ts, 14 Cables
    int col;       // Every Piece has its color
    int oinject;   // For memeory, who many packets to send
    int injector;  // Pakckets to send = Station
    int ccol;      // Piece has its Current color
    int hcol;      // and its next updatecolor
    int wait;      // Pause - collision delay

    public pipeCanvas(byte what, int pos, int col)
    {
      this.what = what;
      this.pos = pos;
      this.col = col;
      this.ccol = Const.WHITE;    // White
      this.injector = 0;
      this.wait = 0;              // send immediate
      // System.out.println("InitParams: "+what+" "+pos+" "+col);
      repaint();
    }

    public void paint(Graphics g)
    {
	int w = size().width;
	int h = size().height;

	g.setColor(Const.pc_col[ccol]);
	// System.out.println("Params: "+what+" "+pos+" "+ccol);
	switch (what)
	{
	case Const.T:
	  g.fillRect(15,0,10,20);
	  g.fillRect(0,20,40,10);
	  break;
	case Const.C:
	  g.fillRect(0,20,40,10);
	  break;
	case Const.L:
	  g.fillRect(0,0,10,50);
	  g.fillRect(0,20,40,10);
	  break;
	case Const.R:
	  g.fillRect(30,0,10,50);
	  g.fillRect(0,20,40,10);
	  break;

	}

       // g.setColor(Color.black);

    }

    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension minimumSize()
    {
	return new Dimension(40,50);
    }

    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension preferredSize()
    {
	return minimumSize();
    }

    public void redraw(int col)
    {
      this.ccol = col;
      repaint();
    }

    public void inject(int i)   // This PC injects some data
    {
      this.oinject = i;
      this.injector = i;
    }

    public void decInject()   // This PC injects some data
    {
      this.injector --;
    }

    public int getInject()   // This PC injects some data
    {
      return(this.injector);
    }
    public int getOInject()   // This PC injects some data
    {
      return(this.oinject);
    }

    public void recolor()
    {
      this.ccol = this.col;
      repaint();
    }

    public int getColor()   // Gets the actual color
    {
      return(this.ccol);
    }
    public int getOColor()   // Gets the original color
    {
      return(this.col);
    }
    public void setColor(int col)   // Sets the next color for update
    {
      this.hcol = col;
    }
    public void update()
    {
      this.ccol = this.hcol;
      repaint();
    }

    public int getWait()
    {
      return(this.wait);
    }

    public void decWait()
    {
      if (this.wait > 0)
	this.wait--;
    }

    public void setWait(int wait)
    {
      this.wait = wait;
    }

}
//-

//+ "class nrCanvas extends Canvas"
class nrCanvas extends Canvas
{
    int act;
    int height;
    int oh=0;

    public void paint(Graphics g)
    {
      int w = size().width;
      int h = size().height;

      g.setColor(Color.lightGray);
      g.fillRect(0, 0, w , h);

      g.setColor(Color.black);
      g.fillRect(0, (height+oh)*act+6, 10, 10);


   }

   public void setH(int h)
   {
     this.oh = h;
   }

   public void setAct(int t)
   {
     this.act = t;
     repaint();
   }

    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension minimumSize()
    {
      Graphics g = getGraphics();
      Font f = g.getFont();
      FontMetrics fm = g.getFontMetrics();

      this.height = fm.getHeight() +13;

      // System.out.println("FontHeight: "+height);
      return new Dimension(15,Const.MAXSLICE * (height+oh));
    }

    //If we don't specify this, the canvas might not show up at all
    //(depending on the layout manager).
    public Dimension preferredSize()
    {
	return minimumSize();
    }
}
//-

/*
class FramedArea extends Panel
{
    public FramedArea(Ether controller)
    {
	...<em>//Set the layout manager.
	   //Add any Components this Panel contains...</em>
    }

    //Ensure that no Component is placed on top of the frame.
    //The inset values were determined by trail and error.

    public Insets insets()
    {
	return new Insets(4,4,5,5);
    }

    //Draw the frame at this Panel's edges.
    public void paint(Graphics g)
    {
	Dimension d = size();
	Color bg = getBackground();

	g.setColor(bg);
	g.draw3DRect(0, 0, d.width - 1, d.height - 1, true);
	g.draw3DRect(3, 3, d.width - 7, d.height - 7, false);
    }
}

*/