import java.awt.*;

public class Antenna extends java.applet.Applet
{
  final int x_dim = 300;
  final int y_dim = 300;

  AntennaCanvas graph;
  Choice lin_db;
  Label db_ring1;
  Label db_ring2[] = new Label[2];
  Label db_ring3[] = new Label[2];
  Label d_number;
  Label d_distance;
  Label d_phase;
  Label v_number;
  Label v_distance;
  Label v_phase;
  Label ampl_label;
  Label v_amplitude[] = new Label[10];
  Label range[] = new Label[3];
  Scrollbar sb_number;
  Scrollbar sb_distance;
  Scrollbar sb_phase;
  Scrollbar amplitude[] = new Scrollbar[10];
  Scrollbar sb_range;
  CheckboxGroup cbg;
  GridLayout grid;

  public void init()
  {

      setLayout( null);

	graph = new AntennaCanvas( this );
	graph.reshape( 0, 0, x_dim, y_dim );
	add( graph );

      range[0] = new Label("dynamic range");
      range[0].reshape(x_dim + 5,190,94,15);
      add(range[0]);  

	d_number = new Label( "num" );
	d_number.reshape( x_dim + 10, 0, 50, 14 );
	add( d_number );

	d_distance = new Label( "dist" );
	d_distance.reshape( x_dim + 10, 20, 50, 14 );
	add( d_distance );

	d_phase = new Label( "phase" );
	d_phase.reshape( x_dim + 10, 40, 50, 14 );
	add( d_phase );

      ampl_label = new Label("Amplitudes: ");
      ampl_label.reshape( x_dim + 10,60,350,15);
      add( ampl_label);

	sb_range= new Scrollbar( Scrollbar.HORIZONTAL, 10, 5, 1, 100 );
	sb_range.setPageIncrement( 2 );
	sb_range.reshape( x_dim + 100, 190, 150, 15 );
	add( sb_range);
    
	sb_number = new Scrollbar( Scrollbar.HORIZONTAL, 2, 1, 2, 10 );
	sb_number.setPageIncrement( 2 );
	sb_number.reshape( x_dim + 60, 0, 200, 14 );
	add( sb_number );

	sb_distance = new Scrollbar( Scrollbar.HORIZONTAL, 10, 2, 1, 200 );
	sb_distance.setPageIncrement( 2 );
	sb_distance.reshape( x_dim + 60, 20, 200, 14 );
	add( sb_distance );

	sb_phase = new Scrollbar( Scrollbar.HORIZONTAL, 0, 1, 0, 359 );
	sb_phase.setPageIncrement( 20 );
	sb_phase.reshape( x_dim + 60, 40, 200, 14 );
	add( sb_phase );

        for(int i=0;i<10;i++){
          amplitude[i] = new Scrollbar(Scrollbar.VERTICAL,1,5,1,100); 
          amplitude[i].setPageIncrement( 2 );
          amplitude[i].reshape(x_dim + 20 + i*27,80,20,90);
          add(amplitude[i]);
          v_amplitude[i] = 
             new Label(String.valueOf(101-amplitude[i].getValue()));
          v_amplitude[i].reshape(x_dim + 20 + i*27,171,25,15);
          add(v_amplitude[i]);
        } 
      
        range[1] = new Label(String.valueOf(-sb_range.getValue()));
        range[1].reshape( x_dim + 252, 190, 40, 15 );
        add( range[1] );

        range[2] = new Label("dB");
        range[2].reshape( x_dim + 293, 190, 40, 15 );
        add( range[2] );


	v_number = new Label( String.valueOf( sb_number.getValue() ) );
	v_number.reshape( x_dim + 260, 0, 35, 14 );
	add( v_number );

	v_distance = new Label( String.valueOf( sb_distance.getValue() ) );
	v_distance.reshape( x_dim + 260, 20, 35, 14 );
	add( v_distance );

	v_phase = new Label( String.valueOf( sb_phase.getValue() ) );
	v_phase.reshape( x_dim + 260, 40, 35, 14 );
	add( v_phase );

      db_ring1 = new Label("0dB");
      db_ring1.setForeground(Color.white );
      db_ring1.reshape(0,y_dim,30,20);
	add( db_ring1 );

      db_ring2[0] = new Label( String.valueOf((int)(-sb_range.getValue()/3)));
      db_ring2[0].reshape((int)(x_dim/6),y_dim,20,20);
      db_ring2[0].setForeground(Color.white );
      db_ring2[1] = new Label("dB");
      db_ring2[1].reshape((int)(x_dim/6)+21,y_dim,20,20);
      db_ring2[1].setForeground(Color.white );
	add( db_ring2[0] );
	add( db_ring2[1] );


      db_ring3[0] = new Label( String.valueOf((int)(-2*sb_range.getValue()/3)));
      db_ring3[0].reshape((int)(2*x_dim/3),y_dim,20,20);
      db_ring3[0].setForeground(Color.white );
      db_ring3[1] = new Label("dB");
      db_ring3[1].reshape((int)(2*x_dim/3)+21,y_dim,20,20);
      db_ring3[1].setForeground(Color.white );
	add( db_ring3[0] );
	add( db_ring3[1] );
      

      lin_db = new Choice();
      lin_db.addItem("Using dB scale with Dynamic Range");
      lin_db.addItem("Using linear scale");
      lin_db.reshape(x_dim+50,250,200,35);
      add(lin_db);

//     grid = new GridLayout(1,2));
//     CheckboxGroup cbg = new CheckboxGroup();
//     grid.add(new Checkbox("linear", cbg, true));
//     grid.add(new Checkbox("db", cbg, false));
     

	repaint();
  }

  public boolean handleEvent( Event event )
  {
    if ( event.id == Event.SCROLL_ABSOLUTE ||
	   event.id == Event.SCROLL_LINE_DOWN ||
	   event.id == Event.SCROLL_LINE_UP ||
	   event.id == Event.SCROLL_PAGE_DOWN ||
	   event.id == Event.SCROLL_PAGE_UP )
	{
    if(lin_db.getSelectedIndex()==0){
        range[1].setText(String.valueOf(-sb_range.getValue()));
        db_ring1.setText("0dB");
        db_ring2[0].setText( String.valueOf((int)(-sb_range.getValue()/3)));
        db_ring3[0].setText( String.valueOf((int)(-2*sb_range.getValue()/3)));
        db_ring2[1].setText("dB");
        db_ring3[1].setText("dB"); 
   }
    else{
        range[1].setText("n/a");
        db_ring1.setText("1");
        db_ring2[0].setText("2/3");
        db_ring3[0].setText("1/3");
        db_ring2[1].setText("");
        db_ring3[1].setText(""); 
   }

        v_number.setText(String.valueOf(sb_number.getValue()));
        v_distance.setText(String.valueOf((double)sb_distance.getValue()/100));
        v_phase.setText(String.valueOf(sb_phase.getValue()));
        for(int i=0;i<10;i++){
          if(i < sb_number.getValue())
            v_amplitude[i].setText(String.valueOf(101-amplitude[i].getValue()));
          else
            v_amplitude[i].setText("n/a");
        }

	  graph.repaint();

	  return true;
	}

	return super.handleEvent( event );
  }

  public void paint( Graphics g )
  {
	graph.paint( g );
  }
}


class AntennaCanvas extends Canvas
{
  Antenna parent;
  double phase;
  double dist;
  double n;
 
  double r[] = new double[ 360 ];
  int x[] = new int[ 361 ];
  int y[] = new int[ 361 ];

  AntennaCanvas( Antenna applet )
  {
	parent = applet;
  }


  private double f( int degree )
  {
    double result=0.0,real=0.0,imag=0.0;
    int i=0,amp;
    double AF[][]=new double[10][2];

      //  getting psi = beta*dist*cos(theta) + phase
      //  since dist is in terms of lambda:
      //  psi = 2*Pi*dist*cos(theta) + phase

      double costheta = Math.cos( degree * Math.PI / 180.0 );
	double psi = (Math.PI * 2.0 * dist * costheta + phase );
   
      try 
      { 
        for(i=0; i<n; i++){
          amp=(101-parent.amplitude[i].getValue());

          AF[i][0] = 
           amp*Math.cos((i+1)*psi);
          AF[i][1] = 
           amp*Math.sin((i+1)*psi);
        }
        for(i=0; i<n; i++){
          real += AF[i][0];
          imag += AF[i][1];
        }
        result = Math.sqrt(real*real+imag*imag);
      }
      catch ( ArithmeticException ae )
      {
      result = 0.0;
      }

	return result;
  }


  public void paint( Graphics g)
  {
	int i,tmp_x,tmp_y;
        double dyn;
	int xs = parent.x_dim / 2;
	int ys = parent.y_dim / 2;

	n     = parent.sb_number.getValue();
	dist  = parent.sb_distance.getValue() / 100.0;
        phase = parent.sb_phase.getValue() * Math.PI / 180.0;	
        dyn   = -parent.sb_range.getValue();
  
	g.setColor( Color.lightGray );
	g.fillRect( 0, 0, parent.x_dim, parent.y_dim );

	g.setColor( Color.white );

      g.drawLine(1,ys+4,1,2*ys);
      g.drawLine((int)(xs/3),ys,(int)(xs/3),2*ys);
      g.drawLine((int)(4*xs/3),ys,(int)(4*xs/3),2*ys);

	g.setColor( Color.black );

      g.drawOval(0,0,2*xs,2*ys);    
      g.drawOval((int)(xs/3),(int)(ys/3),
                 (int)(4*xs/3),(int)(4*ys/3));
      g.drawOval((int)(2*xs/3),(int)(2*ys/3),
                 (int)(2*xs/3),(int)(2*ys/3));

      g.setColor(Color.gray);

      for ( i = 0; i <= 359; i=i+30){
        tmp_x=(int)(xs+Math.cos(Math.PI*i/180)*xs);
        tmp_y=(int)(ys+Math.sin(Math.PI*i/180)*ys);
        g.drawLine(xs,ys,tmp_x,tmp_y);
//        g.setColor(Color.blue);
//        g.drawString(String.valueOf(i),tmp_x,tmp_y);
      }


      for ( i = 0; i <= 359; i++ )
        r[ i ] = f( i + 1 );

        scale();


    if(parent.lin_db.getSelectedIndex() == 0){
        for ( i = 0; i <= 359; i++ )
        {
         try
         {        
          r[i] =  20*(Math.log(r[i])/2.30258);
          if(r[i] < dyn)
            r[i] = 0.0;
          else r[i] -= dyn;

         }
         catch ( ArithmeticException ae )
         {
         r[i] = 0.0;
         }
        } 
        scale();          
    }



	for ( i = 0; i <= 359; i++ )
	{
	  double angle = ( ( double ) ( i  + 1 ) ) * Math.PI / 180.0; 

	  x[ i ] = ( int ) ( r[ i ] * Math.cos( angle ) * xs ) + xs;
	  y[ i ] = ( int ) ( ys - ( r[ i ] * Math.sin( angle ) * ys ) );
	}

	x[ 360 ] = x[ 0 ];
	y[ 360 ] = y[ 0 ];

	g.setColor( Color.red );
	g.drawPolygon( x, y, x.length );
  }

  private void scale()
  {
	double max = 0.0;
	int i;

	for ( i = 0; i <= 359; i++ )
	  if ( r[ i ] > max )
	    max = r[ i ];

	for ( i = 0; i <= 359; i++ )
	  r[ i ] /= max;
  }
}