import java.awt.*;
import java.applet.*;
import java.util.Vector;
import java.util.Stack;
import java.lang.Integer;

public class DrawSmallIFS extends Applet 
{
     public byte newStage;
     public byte currentStage;
     public final byte DRAWPOLY = 0;
     public final byte INIT = 1;
     public final byte DRAWIFS = 2;
     DrawSmallIFS difs;
     DrawSmallPolyPanel dpp;
     DrawSmallControlsE1 dcE1;
     DrawSmallControlsS1 dcS1;
     SouthSmallPanel sp;
     DrawSmallInitPanel dip;
     DrawSmallControlsE2 dcE2;
     DrawSmallControlsS2 dcS2;
     DrawSmallControlsS3 dcS3;
     DrawSmallPanel dp;
     RedrawSmallControls rdc;
     BorderLayout b;

     public void init() 
     {
	newStage = DRAWPOLY;
	currentStage = 3;
	DrawSmallIFS difs = new DrawSmallIFS();
	dpp = new DrawSmallPolyPanel(this);
	rdc = new RedrawSmallControls(this);
	dcS1 = new DrawSmallControlsS1(dpp,this,rdc);
	dcE1 = new DrawSmallControlsE1(dpp,dcS1,this);
	dip = new DrawSmallInitPanel();
	dcS2 = new DrawSmallControlsS2(dip,this,dpp);
	dcE2 = new DrawSmallControlsE2(dip,this);
	dp = new DrawSmallPanel(dcE2, dip, dcS2,this);
	dcS3 = new DrawSmallControlsS3(this,dp);
	sp = new SouthSmallPanel(this);
	b = new BorderLayout();
	setLayout(b);
	resetLayout();
     }

     public boolean handleEvent(Event e) 
     {
	if (e.id == Event.WINDOW_DESTROY) 
	{
	    System.exit(0);
	    return true;
	}
	else return super.handleEvent(e);
     }

     public void resetLayout()
     {
	if ( currentStage == DRAWPOLY )
	{
	     remove(dpp);
	     remove(dcE1);
	     remove(dcS1);
	     add( "East", dcE2 );
	     add( "South", sp );
	}
	if ( currentStage == INIT )
	{
	     remove(dip);
	}
	if ( currentStage == DRAWIFS )
	{
	     remove(dp);
	     sp.remove( dcS3 );
	     sp.add( "Center", dcS2 );
	}
	if ( newStage == DRAWPOLY )
	{
	     remove(dcE2);
	     remove( sp );
	     add( "East", dcE1 );
	     add( "Center", dpp );
	     add("South", dcS1 );
	     dcE1.show();
	     dcS1.show();
	     dpp.show();
	     (dpp.getParent()).validate();
	     setCurrentStage(DRAWPOLY);
	}
	if ( newStage == INIT )
	{
	     add( "Center", dip );
	     dip.clearRect();
	     sp.show();
	     dcE2.show();
	     dcS2.show();
	     dip.show();
	     (dip.getParent()).validate();
	     setCurrentStage(INIT);
	}
	if ( newStage == DRAWIFS )
	{
	     sp.remove( dcS2 );
	     sp.add( "Center", dcS3 );
	     add( "Center", dp );
	     dcS3.show();
	     dp.show();
	     (dp.getParent()).validate();
	     setCurrentStage(DRAWIFS);
	}
     }

     public void setNewStage( byte stage )
     {
	switch (stage)
	{
	     case DRAWPOLY:
	     case INIT:
	     case DRAWIFS:
		this.newStage = stage;
		break;
	     default:
		throw new IllegalArgumentException();
	}
     }

     public void setCurrentStage( byte stage )
     {
	switch (stage)
	{
	     case DRAWPOLY:
	     case INIT:
	     case DRAWIFS:
		this.currentStage = stage;
		break;
	     default:
		throw new IllegalArgumentException();
	}
     }

     public void initBigPoly()
     {
	if (( dcE1.sbe.getValue() >= 93 )&&( dcS1.sbs.getValue() <= 1 ))
	{
	     dcE1.le.setText("0");
	     dcS1.ls1.setText("0");
	     dpp.polyDrawn[0] = dpp.OFF;
	     for ( int i = 0 ; i < 2 ; i++ )
	     {
		for ( int j = 0 ; j < 5 ; j++ )
		{
		     dpp.poly[0][i][j] = 0;
		     dpp.elPoly[0][0][i][j] = 0;
		     dpp.elPoly[1][0][i][j] = 0;
		}
	     }
	     dpp.repaint();
	}
     }

     public static void main(String args[]) 
     {
	Frame f = new Frame("DrawSmallIFS");
	DrawSmallIFS difs = new DrawSmallIFS();
	difs.init();
	difs.start();

	f.add("Center", difs);
	f.resize(400, 430);
	f.show();
     }
}

class DrawSmallControlsS1 extends Panel
{
     Label ls1;
     Scrollbar sbs;
     DrawSmallPolyPanel dpp;
     DrawSmallIFS difs;
     RedrawSmallControls rdc;

     public DrawSmallControlsS1( DrawSmallPolyPanel dpp, DrawSmallIFS difs,
				 RedrawSmallControls rdc )
     {
	this.dpp = dpp;
	this.difs = difs;
	this.rdc = rdc;
	setBackground(Color.white);
	setLayout(new BorderLayout());
	sbs = new Scrollbar( Scrollbar.HORIZONTAL );
	sbs.setValues( 0, 0, 0, 150 );
	ls1 = new Label( "now 1 " , 1 );
	add("South", sbs );
	add("West", ls1 );
	add("East", new Button("Initialize"));
 	add("Center", rdc );
    }

     public boolean handleEvent(Event evt)
     {
	if (( evt.id == Event.SCROLL_ABSOLUTE
	     || evt.id == Event.SCROLL_LINE_DOWN
	     || evt.id == Event.SCROLL_LINE_UP
	     || evt.id == Event.SCROLL_PAGE_DOWN
	     || evt.id == Event.SCROLL_PAGE_UP )&&( evt.target == sbs ))
	{
	     ls1.setText( String.valueOf(sbs.getValue()) );
	     difs.dcE1.le.setText( String.valueOf(94 - difs.dcE1.sbe.getValue()));
	     dpp.setPoly( (byte)1, (sbs.getValue()));
	     if ( sbs.getValue() <= 1 )
	     {
		difs.initBigPoly();
	     }
	     else dpp.polyDrawn[0] = dpp.ON;
	     dpp.repaint();
	     return true;
	}
	else return super.handleEvent ( evt );
     }

     public boolean action( Event e, Object arg )
     {
	if ( arg.equals("Initialize"))
	{
	     difs.setNewStage(difs.INIT);
	     difs.sp.ls2.setText
			("Chose the number of iterations, an initial rectangle and a fractal");
	     difs.resetLayout();
	     return true;
	}
     return super.action( e, arg );
     }
}

class DrawSmallControlsE1 extends Panel
{
     Label le;
     Scrollbar sbe;
     DrawSmallPolyPanel dpp;
     DrawSmallControlsS1 dcS1;
     DrawSmallIFS difs;

     public DrawSmallControlsE1(DrawSmallPolyPanel dpp,DrawSmallControlsS1 dcS1,
				 DrawSmallIFS difs)
     {
	this.dpp = dpp;
	this.dcS1 = dcS1;
	this.difs = difs;
	setBackground(Color.white);
	setLayout(new BorderLayout());
	sbe = new Scrollbar( Scrollbar.VERTICAL );
	sbe.setValues( 94, 0, 0, 94 );
	le = new Label( "next 2" , 1 );
	add("East", sbe );
	add("North", le );
	add("South", new Button("Redraw"));
     }

     public boolean handleEvent(Event evt)
     {
	if (( evt.id == Event.SCROLL_ABSOLUTE
	     || evt.id == Event.SCROLL_LINE_DOWN
	     || evt.id == Event.SCROLL_LINE_UP
	     || evt.id == Event.SCROLL_PAGE_DOWN
	     || evt.id == Event.SCROLL_PAGE_UP )&&( evt.target == sbe ))
	{
	     le.setText( String.valueOf(94 - sbe.getValue()));
	     dcS1.ls1.setText( String.valueOf(dcS1.sbs.getValue()) );
	     dpp.setPoly( (byte)2, (94 - sbe.getValue()));
	     if ( sbe.getValue() >= 93 )
	     {
		difs.initBigPoly();
	     }
	     else dpp.polyDrawn[0] = dpp.ON;
	     dpp.repaint();
	     return true;
	}
	else return super.handleEvent ( evt );
     }

     public boolean action( Event e, Object arg )
     {
	if ( arg.equals("Redraw"))
	{
	     sbe.setValue(94);
	     le.setText("0");
	     dcS1.sbs.setValue(0);
	     dcS1.ls1.setText("0");
	     dpp.initPoly();
	     return true;
	}
     return super.action( e, arg );
     }
}

class RedrawSmallControls extends Panel
{
     DrawSmallIFS difs;
     DrawSmallPolyPanel dpp;
     private Button[] rd = { new Button("1Sky"),
			new Button("2Navy"), new Button("3Green"),
			new Button("4Rose") };
     Label lrd;
     Font f;

     public RedrawSmallControls(DrawSmallIFS difs)
     {
	this.difs = difs;
	this.dpp = difs.dpp;
	lrd = new Label( "Redraw:", 1 );
	f = new Font("Geneva", Font.PLAIN, 9 );
	lrd.setFont(f);
	setBackground(Color.lightGray);
	setLayout( new GridLayout(1,5));
	add( lrd );
	for ( int i = 0 ; i < 4 ; i++ )
	{
	     add( rd[i] );
	     rd[i].setForeground(dpp.col[i+1]);
	}
     }

      public boolean action(Event e, Object arg) 
     {
	for ( int i = 0 ; i < 4 ; i++ )
	{
	     if ((e.target.equals(rd[i]))&&(dpp.mode == dpp.LINE)&&
		(dpp.polyDrawn[i + 1] == dpp.ON))
	     {
		dpp.redraw++;
		dpp.polyStack.push( new Integer(dpp.k ));
		dpp.k = i + 1;
		dpp.polyDrawn[i + 1] = dpp.OFF;
		for ( int n = 0 ; n < 2 ; n++ )
		{
		     for (int j = 0 ; j < 5 ; j++ )
		     {
			dpp.poly[i+1][n][j] = 0;
		     	dpp.elPoly[0][i+1][n][j] = 0;
		     	dpp.elPoly[1][i+1][n][j] = 0;
		     }
		}
		dpp.repaint();
		difs.dcS1.ls1.setText("now " + String.valueOf(dpp.k));
		if ((((Integer)dpp.polyStack.peek()).intValue())<5 )
			difs.dcE1.le.setText("next " +
			((Integer)dpp.polyStack.peek()).toString());
		else difs.dcE1.le.setText("Redraw");
		return true;
	     }
	}
	return super.action( e, arg );
      }
}

class DrawSmallPolyPanel extends Panel 
{
     DrawSmallIFS difs;
     public static final byte LINE = 0;
     public static final byte POLY = 1;
     byte  mode = LINE;
     public static final byte ON = 1;
     public static final byte OFF = 0;
     byte drawenable = OFF;
     public static final byte RED = 0;
     public static final byte BLACK = 1;
     byte colour = RED;
     int redraw = 0;
     Stack polyStack = new Stack();
     byte polyDrawn[] = new byte[5];
     int [][][] poly = new int[5][2][5];
     int [][][][] elPoly = new int[2][5][2][5];
     Color[] col = { new Color(0,0,0), new Color(0,0,0), new Color(0,0,0), new 
		Color(0,0,0), new Color(0,0,0)};
     int i,j,m,SBROT,SBTR;
     int k = 1;
     float [] dx = new float[2];

     public DrawSmallPolyPanel(DrawSmallIFS difs) 
     {
	this.difs = difs;
	setBackground(Color.white);
	col[0] = Color.yellow;
	col[1] = Color.cyan;
	col[2] = Color.blue;
	col[3] = Color.green;
	col[4] = Color.magenta;
	polyStack.push( new Integer( 5 ));
	for ( i = 0 ; i < 4 ; i++ )
	{
	     polyStack.push(new Integer( 5 - i ));
	}
     }

     public boolean handleEvent(Event evt) 
     {
         if ( k < 5 )
         {
	switch ( evt.id )
	{
	     case Event.MOUSE_DOWN:
	     {
		if ( mode == LINE )
		{
		     poly[k][0][0] = evt.x;
		     poly[k][1][0] = evt.y;
		     shrinkLine(evt);
		     difs.dcE1.le.setText("x " + poly[k][0][0]);
		     difs.dcS1.ls1.setText("y " + poly[k][1][0]);
		     drawenable = ON;
		     return true;
		 }
		else if ( mode == POLY )
		     {
			poly[k][0][2] = evt.x;
			poly[k][1][2] = evt.y;
			colour = RED;
			shrinkPoly();
			difs.dcE1.le.setText("x " + poly[k][0][2]);
			difs.dcS1.ls1.setText("y " + poly[k][1][2]);
			drawenable = ON;
			repaint();
			return true;
		     }
	      }
	     case Event.MOUSE_DRAG:
	     {
		if ( mode == LINE )
		{
		     poly[k][0][1] = evt.x;
		     poly[k][1][1] = evt.y;
		     colour = RED;
		     shrinkLine(evt);
		     difs.dcE1.le.setText("x " + poly[k][0][1]);
		     difs.dcS1.ls1.setText("y " + poly[k][1][1]);
		     repaint();
		     return true;
		}
		else if ( mode == POLY )
		       {
			poly[k][0][2] = evt.x;
			poly[k][1][2] = evt.y;
			colour = RED;
			shrinkPoly();
			difs.dcE1.le.setText("x " + poly[k][0][2]);
			difs.dcS1.ls1.setText("y " + poly[k][1][2]);
			repaint();
			return true;
		      }
	     }
	     case Event.MOUSE_UP:
	     {
		if ( mode == LINE )
		{
		     poly[k][0][1] = evt.x;
		     poly[k][1][1] = evt.y;
		     colour = BLACK;
		     shrinkLine(evt);
		     repaint();
		     return true;
		}
		else if ( mode == POLY )
		       {
			poly[k][0][2] = evt.x;
	     		poly[k][1][2] = evt.y;
			colour = BLACK;
			shrinkPoly();
			polyDrawn[k] = ON;
			if ( redraw != 0 )
			{
			     drawenable = OFF;
			     k = ((Integer)polyStack.pop()).intValue();
			     mode = LINE;
			     redraw--;
			     if ( k<5) difs.dcS1.ls1.setText("now " + String.valueOf(k));
			     else difs.dcS1.ls1.setText("done");
			     if ((((Integer)polyStack.peek()).intValue())<5)
					difs.dcE1.le.setText("next " + 
					((Integer)polyStack.peek()).toString());
			     else difs.dcE1.le.setText("Redraw");
			}
			else
			{
			     if ( k<4) difs.dcS1.ls1.setText("now " + String.valueOf(k+1));
			     else difs.dcS1.ls1.setText("done");
			     if (k<3) difs.dcE1.le.setText("next " + String.valueOf(k+2));
			     else difs.dcE1.le.setText("Redraw");
			}
	     		repaint();
	     		return true;
		      }
	     }
	 }
          }
          return super.handleEvent(evt);
     }

     public void shrinkLine(Event evt)
     {
	if ( evt.id == Event.MOUSE_DOWN )
	{
	     for ( i = 0 ; i < 2 ; i++ )
	     {
		for ( j = 0 ; j < 2 ; j++ )
		{
		     if (( 1 - 2*i )*poly[k][j][0] + i*299 < 2 )
		     {
			poly[k][j][0] = i*299 + 2 - 4*i ;
		     }
		}
	     }
	}
	if (( evt.id == Event.MOUSE_DRAG)||( evt.id == Event.MOUSE_UP))
	{
	     for ( i = 0 ; i < 2 ; i++ )
	     {
		for ( j = 0 ; j < 2 ; j++ )
		{
		     if (( 1 - 2*i )*poly[k][j][1] + i*299 < 2 )
		     {
			dx[0] = (float)(poly[k][1-j][1] - poly[k][1-j][0]);
			dx[1] = (float)(poly[k][j][1] - poly[k][j][0]);
			poly[k][1-j][1] = poly[k][1-j][0] + (int)((dx[0]/dx[1])*
					( i*299 + 2 - i*4 - poly[k][j][0]));
			poly[k][j][1] = i*299 + 2 - i*4 ;
		     }
		}
	     }
	}
     }

     public void shrinkPoly()
     {
	for ( j = 0 ; j < 2 ; j++ )
	{
	      poly[k][j][3] = poly[k][j][2] - poly[k][j][1]  + poly[k][j][0];
	      poly[k][j][4] = poly[k][j][0];
	}

	for ( m = 0 ; m < 2 ; m++ )
	{
	     for ( i = 0 ; i < 2 ; i++ )
	     {
		for ( j = 0 ; j < 2 ; j++ )
		{
		     if (( 1 - 2*i )*poly[k][j][2+m] + i*299 < 1 )
		     {
			dx[0] = (float)(poly[k][1-j][2+m] - poly[k][1-j][1-m]);
			dx[1] = (float)(poly[k][j][2+m] - poly[k][j][1-m]);
			poly[k][1-j][2+m] = poly[k][1-j][1-m] + (int)((dx[0]/dx[1])*
						( i*299 + 1 - i*2 - poly[k][j][1-m]));
			poly[k][j][2+m] = i*299 + 1 - 2*i ;
		 	poly[k][0][3-m] = poly[k][0][2+m] - poly[k][0][1-m] + 								poly[k][0][0+m];
		 	poly[k][1][3-m] = poly[k][1][2+m] - poly[k][1][1-m] + 								poly[k][1][0+m];
		     }
		}
	     }
	}
     }

     public void initPoly()
     {
	for ( m = 0 ; m < 5 ; m++ )
	{
	     for ( i = 0 ; i < 2 ; i++ )
	     {
		for ( j = 0 ; j < 5 ; j++ )
		{
		     poly[m][i][j] = 0;
		     elPoly[0][m][i][j] = 0;
		     elPoly[1][m][i][j] = 0;
		}
	     }
	}
	while ( !polyStack.empty() )	
	{
	     polyStack.pop();
	}
	polyStack.push( new Integer( 5 ));
	for ( i = 0 ; i < 4 ; i++ )
	{
	     polyStack.push( new Integer( 5 - i ));
	     polyDrawn[i] = OFF;
	}
	polyDrawn[4] = OFF;
	k = 1;
	SBROT = 0;
	SBTR = 0;
	redraw = 0;
	mode = LINE;
	repaint();
     }

     public int [][][] getPoly()
     {
	return poly;
     }

     public void setPoly(byte SB, int SBVAL)
     {
	poly[0][0][1] = 299;
	if ( SB == (byte)1 ) SBROT = SBVAL;
	else SBTR = SBVAL;
	poly [0][0][0] = SBROT;
	poly [0][0][4] = SBROT;
	for ( j = 1 ; j < 4 ; j++ )
	{
	     poly[0][j%2][j] = 299*(j/2) + ( 1 - 2*(j/2))*SBROT;
	     poly[0][(j+1)%2][j] = 299*((j+1)/2 - 2*((j+1)/4));
	}
	for ( j = 0 ; j < 5 ; j++ )
	{
	     poly[0][0][j] = poly[0][0][j] + (((j/2) - 2*(j/4))*SBTR*SBROT )/300 +
			(( 1 - 2*((j+1)/2) + 4*((j+1)/4))*SBTR)/2 +
			(SBROT*SBTR)/300;
	     poly[0][1][j] = poly[0][1][j] - ((j/2) - 2*(j/4))*SBTR - 
			((((j+1)/2) - 2*((j+1)/4))*SBTR*SBROT )/300;
	}
	for ( j = 0 ; j < 5 ; j++ )
	{
	     for ( i = 0 ; i < 2 ; i++ )
	     {
		elPoly[0][0][i][j] = poly[0][i][0] + (( 8 + 4*((j/2) - 2*(j/4)))*
					( poly[0][i][1] - poly[0][i][0] ))/100 +
					(( 8 + 16*(((j+1)/2) - 2*((j+1)/4)))*
					( poly[0][i][3] - poly[0][i][0] ))/100;
		elPoly[1][0][i][j] = poly[0][i][0] + (( 8 + 10*((j/2) - 2*(j/4)))*
					( poly[0][i][1] - poly[0][i][0] ))/100 +
					(( 24 + 4*(((j+1)/2) - 2*((j+1)/4)))*
					( poly[0][i][3] - poly[0][i][0] ))/100;
	     }
	}
	repaint();
     }

     public void paint(Graphics g)
     {
         for ( int PL = 0 ; PL  < 5 ; PL++ )
        {
	if ( polyDrawn[PL] == ON )
	{
	     g.drawPolygon( poly[PL][0] , poly[PL][1] , 5 );
	     g.setColor(col[PL]);
	     g.fillPolygon( elPoly[0][PL][0] , elPoly[0][PL][1] , 5 );
	     g.fillPolygon( elPoly[1][PL][0] , elPoly[1][PL][1] , 5 );
	     g.setColor(Color.black);
	}
        }
        if (( mode == POLY )&&( drawenable == OFF ))
        {
	g.drawLine(poly[k][0][0], poly[k][1][0], poly[k][0][1], poly[k][1][1]);
        }
        if ( drawenable == ON )
        {
	switch ( mode )
	{
	     case LINE:
	     {
		if ( colour == BLACK )
		{
		     g.drawLine(poly[k][0][0], poly[k][1][0], poly[k][0][1], poly[k][1][1]);
		     mode = POLY;
		     drawenable = OFF;
		}
		else
		{
		     g.setColor(Color.red);
		     g.drawLine(poly[k][0][0], poly[k][1][0], poly[k][0][1], poly[k][1][1]);
		     g.setColor(Color.black);
		}
		break;
	     }
	     case POLY: 
	     {
		for ( j = 0 ; j < 5 ; j++ )
		{
		     for ( i = 0 ; i < 2 ; i++ )
		     {
			elPoly[0][k][i][j] = poly[k][i][0] + (( 8 + 4*((j/2) - 2*(j/4)))*
						( poly[k][i][1] - poly[k][i][0] ))/100 +
						(( 8 + 16*(((j+1)/2) - 2*((j+1)/4)))*
						( poly[k][i][3] - poly[k][i][0] ))/100;
			elPoly[1][k][i][j] = poly[k][i][0] + (( 8 + 10*((j/2) - 2*(j/4)))*
						( poly[k][i][1] - poly[k][i][0] ))/100 +
						(( 24 + 4*(((j+1)/2) - 2*((j+1)/4)))*
						( poly[k][i][3] - poly[k][i][0] ))/100;
		     }
		}
		if ( colour == BLACK )
		{
		     g.drawPolygon( poly[k][0] , poly[k][1] , 5 );
		     g.setColor(col[k]);
		     g.fillPolygon( elPoly[0][k][0] , elPoly[0][k][1] , 5 );
		     g.fillPolygon( elPoly[1][k][0] , elPoly[1][k][1] , 5 );
		     g.setColor(Color.black);
		     mode = LINE;
		     if ( !polyStack.empty() ) k = ((Integer)(polyStack.pop())).intValue();
		     drawenable = OFF;
		}
		else
		{
		     g.setColor(Color.red);
		     g.drawPolygon( poly[k][0] , poly[k][1] , 5 );
		     g.setColor(Color.black);
		}
	     }
	}
         }
     }   
}

class DrawSmallInitPanel extends Panel 
{
     int[][] x = new int[2][3];
     int height,width;
     public static final byte RED = 0;
     public static final byte BLACK = 1;
     byte colour = RED;
     float[][] rect = new float[2][3];

     public DrawSmallInitPanel() 
     {
	setBackground(Color.white);
     }

    public boolean handleEvent(Event evt) 
    {
	switch (evt.id)
	{
	       case Event.MOUSE_DOWN:
		x[0][0] = evt.x;
		x[1][0] = evt.y;
	            return true;
	       case Event.MOUSE_UP:
		x[0][1] = evt.x;
		x[1][1] = evt.y;
		colour = BLACK;
		compute();
	            repaint();
	            return true;
	       case Event.MOUSE_DRAG:
		x[0][1] = evt.x;
		x[1][1] = evt.y;
		colour = RED;
		compute();
	            repaint();
	            return true;
	       case Event.WINDOW_DESTROY:
		System.exit(0);
		return true;
	      default:
		return super.handleEvent(evt);
	}
     }

     public void compute()
     {
	if ( x[0][0] != 0 )
	{
	     for ( int j = 0 ; j < 2 ; j++ )
	     {
		for ( int i = 0 ; i < 2 ; i++ )
		{
		     for ( int k = 0 ; k < 2 ; k++ )
		     {
			if (( 1 - 2*j )*x[i][k] + j*298 < 0 ) x[i][k] = j*298;
		     }
		}
	     }
	     if ( x[0][1] < x[0][0] )
	     {
		width = x[0][0] - x[0][1];
		x[0][2] = x[0][1];
	     }
	     else
	     {
		width = x[0][1] - x[0][0];
		x[0][2] = x[0][0];
	     }
	     if ( x[1][1] < x[1][0] )
	     {
		height = x[1][0] - x[1][1];
		x[1][2] = x[1][1];
	     }
	     else
	     {
		height = x[1][1] - x[1][0];
		x[1][2] = x[1][0];
	     }
	}
     }

     public float[][] getRect()
     {
	if (( x[0][2] == 0 )&&( x[1][2] == 0 ))
	{
	     rect[0][0] = 120F;
	     rect[1][0] = 120F;
	     rect[0][1] = .2F;
	     rect[1][2] = .2F;
	}
	else
	{
	     rect[0][0] = x[0][2];
	     rect[1][0] = x[1][2];
	     rect[0][1] = ((float)width)/400;
	     rect[1][2] = ((float)height)/400;
	}
	return rect;
     }

     public void clearRect()
     {
	for ( int i = 0 ; i < 2 ; i++ )
	{
	     for ( int j = 0 ; j < 3 ; j++ )
	     {
		rect[i][j] = 0;
		x[i][j] = 0;
	     }
	}
	width = 0;
	height = 0;
     }

     public void paint(Graphics g)
     {
	if (( colour == BLACK )&&( x[0][0] != 0 ))
	{
	     g.fillRect(x[0][2], x[1][2], width, height);
	}
	else
	{
	     g.setColor(Color.red);
	     g.drawRect(x[0][2], x[1][2], width, height);
	     g.setColor(Color.black);
	}
      }
}

class SouthSmallPanel extends Panel
{
     DrawSmallIFS difs;
     DrawSmallControlsS2 dcS2;
     DrawSmallControlsS3 dcS3;
     BorderLayout sb;
     Label ls2;
     Font f;
     String[] fractal = {"Your Fractal ", "the Barnsley Fern ", "the Snowflake ", 
			"the Winter Tree ", "the Maple Leaf "};

     public SouthSmallPanel( DrawSmallIFS difs )
     {
	this.difs = difs;
	this.dcS2 = difs.dcS2;
	this.dcS3 = difs.dcS3;
	ls2 = new Label
		("Chose the number of iterations, an initial rectangle and a fractal");
	f = new Font("Geneva", Font.PLAIN, 9 );
	ls2.setFont(f);
	sb = new BorderLayout();
	setLayout(sb);
	add("North", ls2 );
	add("Center", dcS2 );
     }
}

class DrawSmallControlsS2 extends Panel
{
     DrawSmallPolyPanel dpp;
     DrawSmallInitPanel dip;
     DrawSmallIFS difs;
     int frac,ntrans;
     int poly [][][] = new int [5][2][5];
     float [][][] trans = new float [5][2][3];
     String oldLabel;
     Button[] buttons2 = {new Button("Restart"), new Button("Yours"), 
			new Button("Fern"), new Button("Flake"),
			new Button("Tree"), new Button("Leaf")};	


     public DrawSmallControlsS2(DrawSmallInitPanel dip, DrawSmallIFS drawIFS, 
				DrawSmallPolyPanel dpp)
     {
	this.dpp = dpp;
	this.dip = dip;
	this.difs = drawIFS;
	setBackground(Color.lightGray);
	for ( int j = 0 ; j < 6 ; j++ )
	{
	     add( buttons2[j] );
	}
     }

     public boolean action( Event evt , Object arg )
     {
	if ((( arg.equals("Yours"))||( arg.equals("Fern"))||( arg.equals("Flake"))||
	   ( arg.equals("Tree"))||( arg.equals("Leaf")))&&
	   ( difs.dp.compState == difs.dp.OFF))
	{
	     difs.setNewStage(difs.DRAWIFS);
	     ntrans = 0;
	     if ( arg.equals("Yours"))
	     {
		frac = 0;
		poly = dpp.getPoly();
		for ( int k = 0 ; k < 5 ; k++ )
		{
	     	     for ( int i = 0 ; i < 2 ; i++ )
	     	     {
			for ( int j = 0 ; j < 2 ; j++ )
			{
		     	     trans[ntrans][i][j+1] = ((float)(poly[k][i][2*j+1] - 
							poly[k][i][0]))/300;
			}
			trans[ntrans][i][0] = poly[k][i][0];	
	     	     }
		     if (( trans[ntrans][0][0] != 0 )||( trans[ntrans][1][0] != 0 )) ntrans++;
		}
	     }
	     if ( arg.equals("Fern"))
	     {
		frac = 1;
		ntrans = 4;
		trans[0][0][0] = (float)(56.25);
		trans[0][1][0] = (float)(0);
		trans[0][0][1] = (float)(.71);
		trans[0][1][1] = (float)(.05);
		trans[0][0][2] = (float)(-.05);
		trans[0][1][2] = (float)(.71);

		trans[1][0][0] = (float)(151.5);
		trans[1][1][0] = (float)(153);
		trans[1][0][1] = (float)(.0075);
		trans[1][1][1] = (float)(.4825);
		trans[1][0][2] = (float)(.0125);
		trans[1][1][2] = (float)(0);

		trans[2][0][0] = (float)(23.25);
		trans[2][1][0] = (float)(260.25);
		trans[2][0][1] = (float)(.1175);
		trans[2][1][1] = (float)(-.2925);
		trans[2][0][2] = (float)(.4125);
		trans[2][1][2] = (float)(.1275);

		trans[3][0][0] = (float)(281.25);
		trans[3][1][0] = (float)(244.5);
		trans[3][0][1] = (float)(-.0725);
		trans[3][1][1] = (float)(-.32);
		trans[3][0][2] = (float)(-.4275);
		trans[3][1][2] = (float)(.1);

		trans[4][0][0] = (float)(0);
		trans[4][1][0] = (float)(0);
		trans[4][0][1] = (float)(0);
		trans[4][1][1] = (float)(0);
		trans[4][0][2] = (float)(0);
		trans[4][1][2] = (float)(0);
	     }
	     else if ( arg.equals("Flake"))
	     {
		frac = 2;
		ntrans = 4;
		trans[0][0][0] = (float)(114.75);
		trans[0][1][0] = (float)(25.08);
		trans[0][0][1] = (float)(.225);
		trans[0][1][1] = (float)(0);
		trans[0][0][2] = (float)(0);
		trans[0][1][2] = (float)(.225);

		trans[1][0][0] = (float)(37.38);
		trans[1][1][0] = (float)(159.54);
		trans[1][0][1] = (float)(.225);
		trans[1][1][1] = (float)(0);
		trans[1][0][2] = (float)(0);
		trans[1][1][2] = (float)(.225);

		trans[2][0][0] = (float)(192.18);
		trans[2][1][0] = (float)(159.59);
		trans[2][0][1] = (float)(.225);
		trans[2][1][1] = (float)(0);
		trans[2][0][2] = (float)(0);
		trans[2][1][2] = (float)(.225);

		trans[3][0][0] = (float)(-.0048);
		trans[3][1][0] = (float)(190.83);
		trans[3][0][1] = (float)(.37);
		trans[3][1][1] = (float)(-.642);
		trans[3][0][2] = (float)(.642);
		trans[3][1][2] = (float)(.37);

		trans[4][0][0] = (float)(0);
		trans[4][1][0] = (float)(0);
		trans[4][0][1] = (float)(0);
		trans[4][1][1] = (float)(0);
		trans[4][0][2] = (float)(0);
		trans[4][1][2] = (float)(0);
	     }
	     else if ( arg.equals("Tree"))
	     {
		frac = 3;
		ntrans = 5;
		trans[0][0][0] = (float)(0);
		trans[0][1][0] = (float)(93.54);
		trans[0][0][1] = (float)(.195);
		trans[0][1][1] = (float)(-.344);
		trans[0][0][2] = (float)(.488);
		trans[0][1][2] = (float)(.433);

		trans[1][0][0] = (float)(199.53);
		trans[1][1][0] = (float)(20.94);
		trans[1][0][1] = (float)(.4);
		trans[1][1][1] = (float)(.252);
		trans[1][0][2] = (float)(-.414);
		trans[1][1][2] = (float)(.361);

		trans[2][0][0] = (float)(158.28);
		trans[2][1][0] = (float)(277.5);
		trans[2][0][1] = (float)(-.058);
		trans[2][1][1] = (float)(-.453);
		trans[2][0][2] = (float)(.07);
		trans[2][1][2] = (float)(-.111);

		trans[3][0][0] = (float)(167.52);
		trans[3][1][0] = (float)(154.53);
		trans[3][0][1] = (float)(-.035);
		trans[3][1][1] = (float)(.469);
		trans[3][0][2] = (float)(-.07);
		trans[3][1][2] = (float)(-.022);

		trans[4][0][0] = (float)(256.86);
		trans[4][1][0] = (float)(74.31);
		trans[4][0][1] = (float)(-.637);
		trans[4][1][1] = (float)(0);
		trans[4][0][2] = (float)(0);
		trans[4][1][2] = (float)(.501);
	     }
	     else if ( arg.equals("Leaf"))
	     {
		frac = 4;
		ntrans = 3;
		trans[0][0][0] = (float)(58.5);
		trans[0][1][0] = (float)(2.25);
		trans[0][0][1] = (float)(.6075);
		trans[0][1][1] = (float)(0);
		trans[0][0][2] = (float)(0);
		trans[0][1][2] = (float)(.5625);

		trans[1][0][0] = (float)(9.75);
		trans[1][1][0] = (float)(153);
		trans[1][0][1] = (float)(.365);
		trans[1][1][1] = (float)(-.3625);
		trans[1][0][2] = (float)(.375);
		trans[1][1][2] = (float)(.375);

		trans[2][0][0] = (float)(180.75);
		trans[2][1][0] = (float)(45);
		trans[2][0][1] = (float)(.39);
		trans[2][1][1] = (float)(.3875);
		trans[2][0][2] = (float)(-.345);
		trans[2][1][2] = (float)(.345);

		trans[3][0][0] = (float)(0);
		trans[3][1][0] = (float)(0);
		trans[3][0][1] = (float)(0);
		trans[3][1][1] = (float)(0);
		trans[3][0][2] = (float)(0);
		trans[3][1][2] = (float)(0);

		trans[4][0][0] = (float)(0);
		trans[4][1][0] = (float)(0);
		trans[4][0][1] = (float)(0);
		trans[4][1][1] = (float)(0);
		trans[4][0][2] = (float)(0);
		trans[4][1][2] = (float)(0);
	     }
	     difs.dp.setTrans();
	     difs.dp.initScreen();
	     difs.sp.ls2.setText("Drawing " + difs.sp.fractal[frac]);
	     difs.resetLayout();
	     difs.dcS3.compute();
	     return true;
	}
	if ( arg.equals("Restart"))
	{
	     difs.setNewStage(difs.DRAWPOLY);
	     dip.clearRect();
	     difs.resetLayout();
	     return true;
	}
	else return super.action(evt, arg);
     }

     public boolean handleEvent( Event evt )
     {
	if (( evt.id == Event.MOUSE_ENTER )&&(evt.target instanceof Button))
	{
	     oldLabel = difs.sp.ls2.getText();
	     for ( int j = 1 ; j < 6 ; j++ )
	     {
		if ( evt.target == buttons2[j] )
		     {
			difs.sp.ls2.setText("This button will draw " + difs.sp.fractal[j-1]);
		     }
	     }
	     if ( evt.target == buttons2[0] )
	     {
		difs.sp.ls2.setText
		("Takes you to the first screen to draw parallelograms.");
	     }
	}
	if (( evt.id == Event.MOUSE_EXIT )&&( evt.target instanceof Button))
	{
	     difs.sp.ls2.setText(oldLabel);
	}
	return super.handleEvent( evt );
     }

     public float[][][] getTrans()
    {
	return trans;
    }

    public int getNtrans()
    {
	return ntrans;
    }
}

class DrawSmallControlsE2 extends Panel 
{
    DrawSmallInitPanel dip;
    DrawSmallIFS difs;
    int n, i, lastn;
    String oldLabel;
    CheckboxGroup iter = new CheckboxGroup();
    Checkbox[] Ch = { new Checkbox("1", iter, false),
		new Checkbox("2", iter, false), new Checkbox("3", iter, false),
		new Checkbox("4", iter, false), new Checkbox("5", iter, false),
		new Checkbox("6", iter, false), new Checkbox("7", iter, false),
		new Checkbox("8", iter, false), new Checkbox("9", iter, false) };
     

    public DrawSmallControlsE2 (DrawSmallInitPanel target, DrawSmallIFS tegrat) 
    {
	this.dip = target;
	this.difs = tegrat;
	setLayout(new GridLayout( 9 , 1 ));
	setBackground(Color.lightGray);
	for ( i = 0 ; i < 9 ; i++ )
	{
	     add( Ch[i] );
	     Ch[i].setBackground( new Color((16320 - 4080*i + 255*i*i )/64,
		 (16320*i*i - 4080*i*i*i + 255*i*i*i*i)/256 , (i*i*255)/64));
	}
     }

     public boolean action(Event e, Object arg) 
    {
	for ( i = 0 ; i < 9 ; i++ )
	{
	     if (e.target.equals(Ch[i]))
	     {
		n = i + 1;
		if ( difs.currentStage == difs.INIT )
		{
		     difs.sp.ls2.setText("You  chose "+ (i+1) +
			" iterations, now choose an initial rectangle and a fractal.");
		     oldLabel = "You  chose "+ String.valueOf(i+1) +
			" iterations, now choose an initial rectangle and a fractal.";
		}
		if ( difs.currentStage == difs.DRAWIFS )
		{
		     difs.sp.ls2.setText("You  chose "+ (i+1) +
			" iterations, Redraw to compute a new image.");
		     oldLabel = "You  chose "+ String.valueOf(i+1) +
			" iterations, Redraw to compute a new image.";
		}
		return true;
	     }
	}
	return super.action( e, arg );
     }

     public boolean handleEvent( Event evt )
     {
	if (( evt.id == Event.MOUSE_ENTER )&&(evt.target instanceof Checkbox))
	{
	     oldLabel = difs.sp.ls2.getText();
	     for ( int j = 0 ; j < 9 ; j++ )
	     {
		if ( evt.target == Ch[j] )
		{
		     difs.sp.ls2.setText("This choice will compute " + (j+1)
					+ " iterations.");
		}
	     }
	}
	if (( evt.id == Event.MOUSE_EXIT )&&( evt.target instanceof Checkbox))
	{
	     difs.sp.ls2.setText(oldLabel);
	}
	return super.handleEvent( evt );
     }

     public boolean keyDown( Event evt, int key )
     {
	if (( key > 48 )&&( key < 58 ))
	{
	     System.out.println(String.valueOf(key));
	     iter.setCurrent(Ch[key - 49]);
	     n = key - 48;
	     return true;
	}
	if (( key < 49 )||(( key > 57 )&&( key < 200 )))
	{
	     if (( difs.currentStage == difs.DRAWIFS )&&
		( difs.dp.compState == difs.dp.OFF ))
	     {
		if ( lastn == n  )
		{
		     iter.setCurrent(Ch[n]);
		     n++;
		}
	     }
	     difs.dcS3.compute();
	     return true;
	}
	return super.keyDown( evt, key );
     }

     public int getn()
     {
	return n;
     }
}

class DrawSmallControlsS3 extends Panel
{
     DrawSmallIFS difs;
     DrawSmallPanel dp;
     String oldLabel;
     Thread compThread;
     Label ls3;
     Button b1 = new Button("Initialize");
     Button b2 = new Button("Redraw");
     Button b3 = new Button("Attractor");

     public DrawSmallControlsS3(DrawSmallIFS target, DrawSmallPanel drawpanel)
     {
	this.difs = target;
	this.dp = drawpanel;
	add( b1 );
	add( b2 );
	add( b3 );
}

     public void compute()
     {
	dp.repaint();
	compThread = new Thread( dp, "compThread" );
	compThread.setPriority(Thread.NORM_PRIORITY);
	compThread.start();
     }


     public boolean action( Event evt , Object arg )
     {
	if ( arg.equals("Initialize")) 
	{
	     if ( compThread != null )
	     {
		compThread.stop();
		compThread = null;
	     }
	     dp.compState = dp.OFF;
	     dp.initScreen();
	     difs.setNewStage( difs.INIT );
	     difs.sp.ls2.setText(
			"Chose the number of iterations, an initial rectangle and a fractal");
	     oldLabel = "Chose the number of iterations, an initial rectangle and a fractal";
	     difs.resetLayout();
	     return true;
	}
	if ((( arg.equals("Redraw"))||( arg.equals("Attractor")))&&
			(dp.compState == dp.OFF ))
	{
	     if ( arg.equals("Attractor")) dp.compDFS = dp.ON;
	     compute();
	     return true;
	}
	else return super.action( evt, arg );
     }

     public boolean handleEvent( Event evt )
     {
	if (( evt.id == Event.MOUSE_ENTER )&&(evt.target instanceof Button))
	{
	     oldLabel = difs.sp.ls2.getText();
	     if ( evt.target == b1 )
	     {
		difs.sp.ls2.setText(
		"Return to the second screen to choose another fractal.");
	     }
	     if ( evt.target == b2 )
	     {
		difs.sp.ls2.setText
		("Redraw the current fractal with " + difs.dcE2.n + " iterations.");
	     }
	     if ( evt.target == b3 )
	     {
		difs.sp.ls2.setText(
		"Draw the current fractal to the level of screen resolution.");
	     }
	}
	if (( evt.id == Event.MOUSE_EXIT )&&( evt.target instanceof Button))
	{
	     difs.sp.ls2.setText(oldLabel);
	}
	return super.handleEvent( evt );
     }
}

class DrawSmallPanel extends Panel implements Runnable
{
    int [][] Screen = new int [300][300];
    float [][][] triplet;
    float [][][] trans = new float [4][2][3];
    int [][] poly = new int[2][4];
    Vector points1 = new Vector(1500);
    Vector points2 = new Vector(1500);
    Vector [] polygon = {points1, points2};
    int h,i,j,k,m,p,q,np,nq, len;
    int HIGH = 1;
    int LOW;
    float mx;
    DrawSmallControlsE2 dcE2;
    DrawSmallInitPanel dip;
    DrawSmallControlsS2 dcS2;
    DrawSmallIFS difs;
    SouthSmallPanel sp;
    int ntrans = 0;
    int depth = 0;
    public static final int OFF = 0;
    public static final int ON = 1;
    int compState = OFF;
    int compDFS = OFF;
    int TOP = 0;
    int BOTTOM = 0;
    int INC = 0;
    int MAX = 60;
    int[] map = new int[MAX + 1];
    float[][] point = new float[MAX + 1][2];
    int level = 0;
    int colour = 0;

    public DrawSmallPanel (DrawSmallControlsE2 target, DrawSmallInitPanel tegrat, 
			DrawSmallControlsS2 drawControls, DrawSmallIFS difs) 
    {
	this.dcE2 = target;
	this.dip = tegrat;
	this.dcS2 = drawControls;
	this.difs = difs;
	this.sp = difs.sp;
	setBackground(Color.white);
     }

     public void setTrans()
     {
	this.trans = dcS2.getTrans();
     }

     public void initScreen()
     {
	LOW = 0;
	for ( i = 0 ; i < 300 ; i++ )
	{
	     for ( j = 0 ; j < 300 ; j++ )
	     {
		Screen [i][j] = 0 ; 
	     }
	}
	polygon[0].removeAllElements();
	polygon[1].removeAllElements();
	polygon[0].addElement(dip.getRect());
     }

     public void run()
     {
        if ( compDFS == ON )
        {
	compState = ON;
	ntrans = dcS2.getNtrans();
	initScreen();
	polygon[0].removeAllElements();
	repaint();
	initCompdfs();
	compFxPt();
	compsdfs();
	LOW = HIGH;
	difs.sp.ls2.setText( difs.sp.fractal[dcS2.frac] + "drawn completely" );
	repaint();
	difs.dcS3.compThread = null;
        }
        else try
        {
	compState = ON;
	HIGH = dcE2.getn();
	dcE2.lastn = HIGH;
	if ( HIGH < LOW )
	{
	     initScreen();
	}
	for ( m = LOW ; m < HIGH ; m++ )
	{
	     len = 0;
	     p = m%2;
	     q = (m+1)%2;
	     np = polygon[p].size();
	     nq = polygon[q].size();
	     for ( h = 0 ; h < np ; h++ )
	     {
		for ( k = 0 ; k < dcS2.getNtrans() ; k++ )
		{
		     triplet = new float[2][2][3];
		     triplet[p] = (float[][])polygon[p].elementAt(h);
		     mx = 0;
		     for ( i = 0 ; i < 2 ; i++ )
		     {
			for ( j = 1 ; j < 3 ; j++ )
			{
			     triplet[q][i][j] = trans[k][i][1]*triplet[p][0][j] +
				trans[k][i][2]*triplet[p][1][j];
			     if ( triplet[q][i][j] > mx ) mx = triplet[q][i][j];
			     else if ( -triplet[q][i][j] > mx ) mx = -triplet[q][i][j];
			}
			triplet[q][i][0] = trans[k][i][1]*triplet[p][0][0] +
					trans[k][i][2]*triplet[p][1][0] + trans[k][i][0];
		     }
		     if ( mx < .001875 )
		     {
			initCompdfs();
			point[0][0] = triplet[q][0][0];
			point[0][1] = triplet[q][1][0];
			compdfs( HIGH - m  );
		     }
		     else if ( len < nq ) 
		           {
			     polygon[q].setElementAt(triplet[q],len );
			     len++;
			}
			else polygon[q].addElement(triplet[q]);
		}
	     }
	     if ( len < nq )
	     {
		for ( i = len ; i < nq ; i++ )
		{
		      polygon[q].removeElementAt( len );
		}
	     }
	     int w = polygon[q].size();
	     java.lang.System.out.println( "polygon[q].size() = " + w );
	     difs.sp.ls2.setText( "Drawing " + difs.sp.fractal[dcS2.frac] + ": with " +
			polygon[q].size() + " parallelograms computed so far.");
	     if ( m < 1 )
	     {
		try
		{
		     Thread.currentThread().sleep(50);
		}
		catch( InterruptedException ignored ) {}
	     }
	     Thread.currentThread().yield();
	}
	LOW = HIGH;
	repaint();
	difs.dcS3.compThread = null;
        }
        catch(OutOfMemoryError e)
        {
	     initScreen();
	     compState = OFF;
	     if (difs.dcS3.compThread != null ) difs.dcS3.compThread = null;
	     difs.setCurrentStage( difs.currentStage );
	     difs.setNewStage( difs.INIT );
	     difs.sp.ls2.setText
		("Java is out of memory, choose smaller rectangle or fewer iterations.");
	     difs.resetLayout();
        }
     }

     public void compsdfs()
     {
	level = 0;
	colour = 0;
	j = 0;
	comp:
	while ( j == 0 )
	{
	     Thread.currentThread().yield();
	     INC = increment(TOP);
	     point[INC][0] = trans[map[TOP]][0][1]*point[TOP][0] + 
			trans[map[TOP]][0][2]*point[TOP][1] + trans[map[TOP]][0][0];
	     point[INC][1] = trans[map[TOP]][1][1]*point[TOP][0] + 
			trans[map[TOP]][1][2]*point[TOP][1] + trans[map[TOP]][1][0];
	     TOP = INC;
	     level++;
	     if ( TOP == BOTTOM )
	     {
		BOTTOM = increment( BOTTOM );
	     }
	     map[TOP] = 0;
	     if ( Screen[(int)point[TOP][0]][(int)point[TOP][1]] != 0 )
	     {
		do
		{
		     TOP = decrement( TOP );
		     level--;
		     if (( TOP == BOTTOM )&&( map[TOP] == ntrans - 1 )) break comp;
		}
		while ( map[TOP] == ntrans - 1 );
		map[TOP]++;
	     }
	     else
	     {
		colour = (int)( level/7 );
		Screen[(int)point[TOP][0]][(int)point[TOP][1]] = colour;
	     }
	}
     }

     public void compFxPt()
     {
	point[1][0] = 150;
	point[1][1] = 150;
	h = dcS2.getNtrans() - 1;
	do
	{
	     point[0][0] = point[1][0];
	     point[0][1] = point[1][1];
	     point[1][0] = trans[h][0][1]*point[0][0] + 
			trans[h][0][2]*point[0][1] + trans[h][0][0];
	     point[1][1] = trans[h][1][1]*point[0][0] + 
			trans[h][1][2]*point[0][1] + trans[h][1][0];
	}
	while (((int)point[1][0] != (int)point[0][0])||((int)point[1][1] != (int)point[0][1]));
	point[0][0] = point[1][0];
	point[0][1] = point[1][1];
     }

     public void initCompdfs()
     {
	TOP = 0;
	BOTTOM = 0;
	INC = 0;
	for ( int t = 0 ; t <= MAX ; t++ )
	{
	     map[t] = 0;
	     point[t][0] = 0;
	     point[t][1] = 0;
	}
     }

     public int increment( int s )
     {
	if ( s == MAX ) s = 0;
	else s++;
	return s;
     }

     public int decrement( int s )
     {
	if ( s == 0 ) s = MAX;
	else s--;
	return s;
     }

     public void compdfs( int d )
     {
	this.depth = d;
	ntrans = dcS2.getNtrans();
	INC = TOP + 1;
	for ( int s = 0 ; s < 2 ; s++ )
	{
	     point[INC][s] = trans[map[TOP]][s][1]*point[TOP][0] + 
			trans[map[TOP]][s][2]*point[TOP][1] + trans[map[TOP]][s][0];
	}
	TOP = INC;
	map[TOP] = 0;
	if ( TOP == depth )
	{
	     Screen[(int)point[TOP][0]][(int)point[TOP][1]] = 1;
	}
	if ( Screen[(int)point[TOP][0]][(int)point[TOP][1]] == 1 )
	{
	     do
	     {
		TOP--;
		if (( TOP == 0 )&&( map[TOP] == ntrans - 1 )) return;
	     }
	     while ( map[TOP] == ntrans - 1 );
	     map[TOP]++;
	     compdfs(depth);
	}
	else
	{
	     compdfs(depth);
	}
     }

     public void paint(Graphics g)
     {
	if (( HIGH == LOW )&&( compState == ON ))
	{
	     k = 0;
	     for ( i = 0 ; i < 300 ; i += 2 )
	     {
		for ( j = 0 ; j < 300 ; j += 2 )
		{
		     if ( Screen [i][j] == 1 ) 
		     {
			g.drawLine( i , j , i , j );
			k++;
		     }
		     if ( Screen [i][j] > 1 )
		     {
			if (Screen [i][j] < 512 )
			{
			     g.setColor( new Color( 255, (int)( Screen [i][j]/2 ), 0 ));
			     g.drawLine( i , j , i , j );
			     k++;
			}
			else if ( Screen [i][j] < 768 )
			     {
				g.setColor( new Color( 767 - Screen [i][j], 255 , 0 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1024 )
			     {
				g.setColor( new Color( 0 , 255 , Screen [i][j] - 768 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1280 )
			     {
				g.setColor( new Color( 0 , 1279 - Screen [i][j], 255 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1536 )
			     {
				g.setColor( new Color( (int)(( Screen [i][j] - 1280 )/4 ) , 0 , 
						(int)( 255 - ( Screen [i][j] - 1280 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1792 )
			     {
				g.setColor( new Color( (int)( 64 - ( 1791 - Screen [i][j] )/4 )
						, 0 , (int)( 255 - ( Screen [i][j] - 1279 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			     else
			     {
				g.setColor(Color.black);
				g.drawLine( i , j , i , j );
				k++;
			     }
			}
			g.setColor(Color.black);
		}
	     }
	     for ( j = 1 ; j < 300 ; j += 2 )
	     {
		for ( i = 0 ; i < 300 ; i += 2 )
		{
		     if ( Screen [i][j] == 1 ) 
		     {
			g.drawLine( i , j , i , j );
			k++;
		     }
		     if ( Screen [i][j] > 1 )
		     {
			if (Screen [i][j] < 512 )
			{
			     g.setColor( new Color( 255, (int)( Screen [i][j]/2 ), 0 ));
			     g.drawLine( i , j , i , j );
			     k++;
			}
			else if ( Screen [i][j] < 768 )
			     {
				g.setColor( new Color( 767 - Screen [i][j], 255 , 0 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1024 )
			     {
				g.setColor( new Color( 0 , 255 , Screen [i][j] - 768 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1280 )
			     {
				g.setColor( new Color( 0 , 1279 - Screen [i][j], 255 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1536 )
			     {
				g.setColor( new Color( (int)(( Screen [i][j] - 1280 )/4 ) , 0 , 
						(int)( 255 - ( Screen [i][j] - 1280 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1792 )
			     {
				g.setColor( new Color( (int)( 64 - ( 1791 - Screen [i][j] )/4 )
						, 0 , (int)( 255 - ( Screen [i][j] - 1279 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			     else
			     {
				g.setColor(Color.black);
				g.drawLine( i , j , i , j );
				k++;
			     }
			}
			g.setColor(Color.black);
		}
	     }
	     for ( i = 1 ; i < 300 ; i += 2 )
	     {
		for ( j = 0 ; j < 300 ; j += 2 )
		{
		     if ( Screen [i][j] == 1 ) 
		     {
			g.drawLine( i , j , i , j );
			k++;
		     }
		     if ( Screen [i][j] > 1 )
		     {
			if (Screen [i][j] < 512 )
			{
			     g.setColor( new Color( 255, (int)( Screen [i][j]/2 ), 0 ));
			     g.drawLine( i , j , i , j );
			     k++;
			}
			else if ( Screen [i][j] < 768 )
			     {
				g.setColor( new Color( 767 - Screen [i][j], 255 , 0 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1024 )
			     {
				g.setColor( new Color( 0 , 255 , Screen [i][j] - 768 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1280 )
			     {
				g.setColor( new Color( 0 , 1279 - Screen [i][j], 255 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1536 )
			     {
				g.setColor( new Color( (int)(( Screen [i][j] - 1280 )/4 ) , 0 , 
						(int)( 255 - ( Screen [i][j] - 1280 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1792 )
			     {
				g.setColor( new Color( (int)( 64 - ( 1791 - Screen [i][j] )/4 )
						, 0 , (int)( 255 - ( Screen [i][j] - 1279 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			     else
			     {
				g.setColor(Color.black);
				g.drawLine( i , j , i , j );
				k++;
			     }
			}
			g.setColor(Color.black);
		}
	     }
	     for ( j = 1 ; j < 300 ; j += 2 )
	     {
		for ( i = 1 ; i < 300 ; i += 2 )
		{
		     if ( Screen [i][j] == 1 ) 
		     {
			g.drawLine( i , j , i , j );
			k++;
		     }
		     if ( Screen [i][j] > 1 )
		     {
			if (Screen [i][j] < 512 )
			{
			     g.setColor( new Color( 255, (int)( Screen [i][j]/2 ), 0 ));
			     g.drawLine( i , j , i , j );
			     k++;
			}
			else if ( Screen [i][j] < 768 )
			     {
				g.setColor( new Color( 767 - Screen [i][j], 255 , 0 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1024 )
			     {
				g.setColor( new Color( 0 , 255 , Screen [i][j] - 768 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1280 )
			     {
				g.setColor( new Color( 0 , 1279 - Screen [i][j], 255 ));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1536 )
			     {
				g.setColor( new Color( (int)(( Screen [i][j] - 1280 )/4 ) , 0 , 
						(int)( 255 - ( Screen [i][j] - 1280 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			else if ( Screen [i][j] < 1792 )
			     {
				g.setColor( new Color( (int)( 64 - ( 1791 - Screen [i][j] )/4 )
						, 0 , (int)( 255 - ( Screen [i][j] - 1279 )/2 )));
				g.drawLine( i , j , i , j );
				k++;
			     }
			     else
			     {
				g.setColor(Color.black);
				g.drawLine( i , j , i , j );
				k++;
			     }
			}
			g.setColor(Color.black);
		}
	     }
	     java.lang.System.out.println("no. of Points drawn is" + k );
	     nq = polygon[q].size();
	     difs.sp.ls2.setText( difs.sp.fractal[dcS2.frac] + "drawn: with " + nq +
			" p-grams computed and " + k + " points drawn." );
	     difs.dcS3.oldLabel = String.valueOf(difs.sp.fractal[dcS2.frac]) +
		"drawn: with " + String.valueOf(nq) + " p-grams computed and " +
				String.valueOf( k ) + " points drawn.";
	     for ( j = 0 ; j < nq ; j++ )
	     {
		for ( i = 0 ; i < 2 ; i++ )
		{
		     poly[i][0] = (int)(((float[][])polygon[q].elementAt( j ))[i][0]);
		     poly[i][1] = (int)(((float[][])polygon[q].elementAt( j ))[i][1]*300 + 
				((float[][])polygon[q].elementAt( j ))[i][0]);
		     poly[i][2] = (int)(((float[][])polygon[q].elementAt( j ))[i][1]*300 + 
				((float[][])polygon[q].elementAt( j ))[i][2]*300 + 
				((float[][])polygon[q].elementAt( j ))[i][0]);
		     poly[i][3] = (int)(((float[][])polygon[q].elementAt( j ))[i][2]*300 + 
				((float[][])polygon[q].elementAt( j ))[i][0]);
		}
		g.fillPolygon( poly[0] , poly[1] , 4 );
		g.drawLine( poly[0][0], poly[1][0], poly[0][0], poly[1][0] );
	     }
	     compState = OFF;
	     if ( compDFS == ON )
	     {
		initScreen();
		compDFS = OFF;
	     }
	}
     }
}