/*



The Mandelbrot Set

Copyright (c) 1996 Simon Arthur



For more information about this program, contact

chroma@mindspring.com.



*/



import java.awt.*;

import java.applet.*;



public class MandelTest extends Applet implements Runnable {

  MandelControls controls;

  MandelCanvas c; // TimeThread T;



    public void init() {

      String s; // parameter string

      float pa,pb,pc,pd; // temp vars for parameters



      s = getParameter("xstart");

      pa = (s==null) ?  -2 : Float.valueOf(s).floatValue();

      s = getParameter("ystart");

      pb = (s==null) ?  -2 : Float.valueOf(s).floatValue();

      s = getParameter("xend");

      pc = (s==null) ?  2 : Float.valueOf(s).floatValue();

      s = getParameter("yend");

      pd = (s==null) ?  2 : Float.valueOf(s).floatValue();

      MandelCanvas c = new MandelCanvas(pa,pb,pc,pd);        

      BorderLayout l = new BorderLayout();

      setLayout(l);

      add("Center",c);

      c.resize(100,100);

      controls = new MandelControls(c);

      add("South",controls);

      controls.resize(200,200);

      c.controls = controls;

      layout();

      c.repaint();

      // start new thread so that the other one will multitask properly

    //  T=new TimeThread();

     // T.start();

     // T.setPriority(Thread.MIN_PRIORITY);

    }

    

    public void start() {

        controls.enable();

    }

    

    public void run() {

        controls.enable();

    }

    

    public void stop() {

        controls.disable();

    }

}



/*****************************************

             MandelCanvas

******************************************/

class MandelCanvas extends Canvas {

  boolean     filled = false;

  Font        font;

  float       Xmin,Ymin,Xmax,Ymax;

  Thread      mythread=null; 

  boolean     DrawMandel=true;

  boolean     DrawMarqueeMode;  

  boolean     DrawThread=false; 

                // Keep track of whether the drawing 

                // thread has been created

  MandelArtist mymandel=null;

  Marquee mymarquee=new Marquee();

  String artistName = "artthread";

  Rectangle r;

  MandelControls controls;                        

      

  public MandelCanvas (float a, float b, float c, float d) {

    Xmin=a; Ymin=b; Xmax=c; Ymax=d;

  }



  public void paint(Graphics g) {

    r=bounds();

    mymarquee.boundx = r.width;

    mymarquee.boundy = r.height;

    if (DrawMandel) {

      if (!DrawThread) {  // we know that the Drawing thread hasn't been made  

        //first give mymandel the information it needs to draw

        mymandel = new MandelArtist(g,artistName);

        //We'll lower the priority a little so it will pre-empt properly 

        mymandel.setPriority(Thread.MIN_PRIORITY);

        mymandel.maxx = r.width;

        mymandel.maxy = r.height;

        mymandel.xstart = Xmin;

        mymandel.ystart = Ymin;

        mymandel.xend = Xmax;

        mymandel.yend = Ymax;

//System.out.println(Xmin);System.out.println(Xmax);System.out.println(Ymin);System.out.println(Ymax);

        mymandel.needsRepaint=true;

        //  now we'll start a new thread of mymandel so it draws in the background

        mymandel.start();

        DrawThread=true;

      }

      else {

        mymandel.needsRepaint=true;

      }

    }

    mymarquee.draw(g);

  }



  public void redraw(float Xmin, float Ymin,float Xmax, float Ymax) {  

    mymandel.stop();                             

    // make a new thread the next time we need to repaint

    DrawThread=false; DrawMandel=true;

    this.Xmin=Xmin;  this.Ymin=Ymin;

    this.Xmax=Xmax;  this.Ymax=Ymax;

    repaint();

  }

  

  public boolean mouseUp(Event evt, int x, int y) {

    mymarquee.resize(x,y);

    controls.f3.setText(String.valueOf(Xmin + (x * ((Xmax-Xmin)/r.width)  ) ) );

    controls.f4.setText(String.valueOf(Ymin + (y * ((Ymax-Ymin)/r.height) ) ) ); 

    repaint();

    return true;

  }



  public boolean mouseDown(Event evt, int x, int y) {

    mymarquee.reset();

    // stop the MandelArtist drawing thread

    mymandel.stop();

    // make a new thread the next time we need to repaint

    DrawThread=false;

    // stop drawing the Mandelbrot for now

    DrawMandel=false;

    // Set new anchor point for marquee

    mymarquee.setAnchorPoint(x,y);

    controls.f1.setText(String.valueOf(Xmin + (x * ((Xmax-Xmin)/r.width)  ) ) );       

    controls.f2.setText(String.valueOf(Ymin + (y * ((Ymax-Ymin)/r.height) ) ) );       

 

    mymarquee.show();



    return true;

  }

  

  public boolean mouseDrag(Event evt, int x, int y) {

    mymarquee.resize(x,y);

    controls.f3.setText(String.valueOf(Xmin + (x * ((Xmax-Xmin)/r.width)  ) ) );       

    controls.f4.setText(String.valueOf(Ymin + (y * ((Ymax-Ymin)/r.height) ) ) );       

    repaint();

    return true;

  }

  

  public void update(Graphics g) {

    mymarquee.draw(g);

    

    if (DrawMandel) {

       paint(g);

    }

  }

}



/*****************************************

             MandelControls

******************************************/





class MandelControls extends Panel {

    TextField f1, f2, f3, f4;

    Label l1,l2,l3,l4,ltest;

    Button b1,b2,b3,b4,breset;

    Choice ch;

    Dimension d;



    MandelCanvas canvas;

 

 

    // set up our buttons, edit fields, etc.

    public MandelControls(MandelCanvas canvas) {

       this.canvas = canvas;

       GridLayout l=new GridLayout(0,4);

       setLayout(l);

       this.setBackground(Color.gray);

       this.setForeground(Color.blue);

       

//       add("z0", new Label(""));  add("z1", new Label(""));

//       add("z2", new Label(""));  add("z3", new Label(""));

       

       add("l1",l1 = new Label(" Xmin="+canvas.Xmin));

       add("l2",l2 = new Label(" Ymin="+canvas.Ymin));

       add("l3",l3 = new Label(" Xmax="+canvas.Xmax));

       add("l4",l4 = new Label(" Ymax="+canvas.Ymax));

       add("f1",f1 = new TextField(String.valueOf(canvas.Xmin),4));

       add("f2",f2 = new TextField(String.valueOf(canvas.Ymin),4));

       add("f3",f3 = new TextField(String.valueOf(canvas.Xmax),4));

       add("f4",f4 = new TextField(String.valueOf(canvas.Ymax),4)); 

       add("b1",b1 = new Button("Zoom In"));

       add("b2",b2 = new Button("Zoom Out"));

       add("b3",b3 = new Button("Julia Set")); b3.disable(); //don't have this working yet

       add("b4",b4 = new Button("Redraw"));

       add("breset",breset = new Button("Reset Values"));

       ch = new Choice();

       ch.addItem("Small"); 

       ch.addItem("Medium");

       ch.addItem("Big");

       ch.select("Big");

       add("ch1",ch);

      



    }

    

    public void setNewValues() {  //update text fields with info about

                                 // new Mandelbrot set

      l1.setText(" Xmin="+canvas.Xmin);

      l2.setText(" Ymin="+canvas.Ymin);

      l3.setText(" Xmax="+canvas.Xmax); 

      l4.setText(" Ymax="+canvas.Ymax);

      f1.setText(String.valueOf(canvas.Xmin));

      f2.setText(String.valueOf(canvas.Ymin));       

      f3.setText(String.valueOf(canvas.Xmax));       

      f4.setText(String.valueOf(canvas.Ymax)); 

    }



    public boolean action(Event ev, Object arg) {

      if (ev.target.equals(b1)) {   //zooom in -- min and max fix it if the user has 

                                    //    switched Xmin & Xmax or Ymin and Ymax

        canvas.redraw(Math.min(Float.valueOf(f1.getText().trim()).floatValue(),Float.valueOf(f3.getText().trim()).floatValue()) ,

                      Math.min(Float.valueOf(f2.getText().trim()).floatValue(),Float.valueOf(f4.getText().trim()).floatValue()) ,

                      Math.max(Float.valueOf(f1.getText().trim()).floatValue(),Float.valueOf(f3.getText().trim()).floatValue()) ,

                      Math.max(Float.valueOf(f2.getText().trim()).floatValue(),Float.valueOf(f4.getText().trim()).floatValue())                      

                      );

      } else if (ev.target.equals(b2)) { // zoom out

        canvas.redraw(canvas.Xmin-(canvas.Xmax-canvas.Xmin)/2,

                      canvas.Ymin-(canvas.Ymax-canvas.Ymin)/2,

                      canvas.Xmax+(canvas.Xmax-canvas.Xmin)/2,

                      canvas.Ymax+(canvas.Ymax-canvas.Ymin)/2);

      } else if (ev.target.equals(b3)) {         // Julia set

     /*   canvas.redraw(canvas.Xmin,

                      canvas.Ymin,

                      canvas.Xmax,

                      canvas.Ymax); */

      } else if (ev.target.equals(b4)) {         // redraw

        canvas.redraw(canvas.Xmin,

                      canvas.Ymin,

                      canvas.Xmax,

                      canvas.Ymax); 

      } else if (ev.target.equals(breset)) { // reset values

        canvas.redraw(-2,-2,2,2); 

      } else if (ev.target.equals(ch)) { // change size of picture

        if (ch.getSelectedItem()=="Small") {

          canvas.mymarquee.hide();

          canvas.resize(50,50); canvas.redraw(canvas.Xmin,canvas.Ymin,canvas.Xmax,canvas.Ymax);

          canvas.move(1,1);         

        } else if (ch.getSelectedItem()=="Medium") {

          canvas.mymarquee.hide();

          canvas.resize(100,100); canvas.redraw(canvas.Xmin,canvas.Ymin,canvas.Xmax,canvas.Ymax);

          canvas.move(1,1);

        } else if (ch.getSelectedItem()=="Big") {

          canvas.mymarquee.hide();

          canvas.resize(300,300); canvas.redraw(canvas.Xmin,canvas.Ymin,canvas.Xmax,canvas.Ymax);

          canvas.move(1,1);

        }

      }                  

      setNewValues();

      return true;

    }

}



/*****************************************

             MandelArtist

******************************************/



class MandelArtist extends Thread {

  boolean needsRepaint = false;

  Graphics gcontext;

  

  int maxx, maxy; // these are the upper limits of the pixels we will be

                  // plotting to 

  float xstart, ystart, xend, yend;  // these are the coordinates

  // of the area of the Mandelbrot set that we will be drawing

  

  public MandelArtist (Graphics g, String s) {

 

//    System.out.println(" - MandelArtist.constructor");

    // copy the graphics context for use in this object

    gcontext=g.create();

    setName(s);  // set the new thread's name

    // gcontext.drawString("constructor", 10, 80); 

  }

  

  public void run() {

    gcontext.drawString("run", 10, 10); 

//    System.out.println(" - MandelArtist.run");

    while (true) {

      try { sleep(500);

      } catch (Exception E) {

        stop();

      }       

       

      if (needsRepaint) {

        doDraw();       

      }

    }

  }

  

//  public void stop() {

//    needsRepaint=false;

//  }



  private int iterate (double x, double y) {

 //   long aold, zsquared=0, xi=(long)(x*10000), yi=(long)(y*10000), ai=0, bi=0;

     /* Iterate over the complex value with real component x 

      * and imaginary component y

      */

     

    int iter=0,maxiter=500;

    double aold, bold, a2old=Double.MAX_VALUE, 

           b2old=Double.MAX_VALUE, zsquared,a=0,b=0,asquared=0,bsquared=0;

           

    aold=0; bold=0;

    asquared=a*a; 

    a=x;

    bsquared=b*b;

    b=y;    

    zsquared=asquared+bsquared;

    for (iter=0; iter<maxiter; iter++) { // calculate value for each point

      a=asquared-bsquared+x;

      asquared=a*a; 

      b=2*aold*b+y;

      if (bold==b && aold==a) { // we have been repeating the same calculation

        iter=maxiter-1;           // so we'll break out on the next loop

    //    yield();

      }

      bsquared=b*b;

      zsquared=asquared+bsquared;

      if ( zsquared>4 )

        break;

      bold=b; aold=a; 

    }

   /*  // an attempt at using integer math to do calculations

   for (ai=0,bi=0,iter=0; iter<500; iter++) { // calculate value for each point

      aold=ai; 

      ai=ai*ai-bi*bi+xi; 

      bi=2*aold*bi+yi; 

      zsquared=ai*ai+bi*bi;

      if ( zsquared>35919520)

        break;

    }*/      

//    System.out.println(zsquared);

    return iter;    

  }





  public void doDraw() {

    

/* Draw the mandelbrot into graphics context gcontext

maxx and maxy are the max numbers of pixels

xstart, ystart, xend and yend marks off the area of the Mandelbrot

set that we will draw.

*/     



    int iter,selcolor,plotx, ploty=0, iterold, plotyold;

    float oldx=xstart, oldy=ystart; 

    float zsquared, xlen=xend-xstart, ylen=yend-ystart;

    float xincr=xlen/maxx, yincr=ylen/maxy;

    Color c[]=new Color[255]; 

    String s;



//System.out.println(" - MandelArtist.doDraw");

    needsRepaint=false; // we won't need to repaint unless we get interrupted

                        // while drawing in which case whis will be set to

                        // false by some other method.

    for(iter=0;iter<255; iter++) {

      c[iter]=new Color(iter*26,iter*2,iter*35);

    }

     

    for (double x = xstart ; x < xend ; x+=xincr) {

      plotx = (int)( (x-xstart) * (maxx/xlen) );

      for (double y = ystart ; y < yend ; y+=yincr) { // Loop over each point on M-set

        iter=0; 

        iter=iterate(x,y);

        gcontext.setColor(c[iter%255]);

        ploty=(int)( (y-ystart) * (maxy/ylen) );        

        gcontext.drawLine( plotx , ploty , plotx , ploty );

      }

    }

  }         

}





/*************************************************************************

                     Marquee

 *************************************************************************/



class Marquee {

// stuff for drawing our Marquee (selection rectangle)

  int rectAnchorX=0, rectAnchorY=0, rectTermX=0, rectTermY=0;

// keep track of where we've last put the marquee on the screen  

  int x1, y1, x2, y2;

  int boundx=Integer.MAX_VALUE,

      boundy=Integer.MAX_VALUE;  //don't make it bigger than these values

  boolean hidden=true, needs_hide=false;



public void draw(Graphics g) {

  // draw the Marquee, if we need to 

  if (!hidden) {

    if (x1!=rectAnchorX || y1!=rectAnchorY || rectTermY!=y2 ||rectTermX!=x2 ) {

    // we need to erase the old rectangle

      put_rectangle(g, x1,y1,x2,y2);

      //now draw new one

      put_rectangle(g,rectAnchorX, rectAnchorY, rectTermX, rectTermY);

      x1=rectAnchorX; y1=rectAnchorY;

      x2=rectTermX; y2=rectTermY;

      hidden=false;

    }

  } else {

  // hidden

  //if it has not already been erased, erase it, otherwise do nothing

    if (needs_hide) {

      put_rectangle(g,rectAnchorX, rectAnchorY, rectTermX, rectTermY);

    }

  }

}



public boolean inMarquee(int x, int y) {

   //find out if the specified point is inside the marquee

//      System.out.println("Marquee.inmarquee");

//      System.out.println(x);

//      System.out.println(rectAnchorX);

//      System.out.println(rectTermX);

//      System.out.println(rectAnchorY);

//      System.out.println(rectTermY);



   if ( ( (x>rectAnchorX && x<rectTermX) || (x>rectTermX && x<rectAnchorX) ) &&

        ( (y>rectAnchorY && y<rectTermY) || (y>rectTermY && y<rectAnchorY) ) )

     {

//        System.out.println("inmarquee - true");

        return true;

     } else { 

//        System.out.println("inmarquee - false");        

        return false;

     }

}

 

public void show() {

  hidden=false;

}



public void hide() {

  hidden=true;

  needs_hide=true;

}

 

public void reset() {

 rectAnchorX=0; rectAnchorY=0; rectTermX=0; rectTermY=0;

}

 

public void resize(int x, int y) {

  // rectTermX=Math.max(x,y); rectTermY=Math.max(x,y);  // make square marq.

  rectTermX=Math.min(x,boundx); // check to see it isn't too big

  rectTermY=Math.min(y,boundx);

}



public void setAnchorPoint (int x, int y) {

    rectAnchorX=x;

    rectAnchorY=y;

}



private void put_rectangle(Graphics g, int x_0, int y_0, int x_1, int y_1) {

   int width, height, startx, starty;

   g.setColor(Color.white);

   g.setXORMode(Color.black);

   width=Math.abs(x_1-x_0); height=Math.abs(y_1-y_0);

   //find upper left corner

   starty=Math.min(y_1,y_0);

   startx=Math.min(x_1,x_0);

   g.drawRect(startx, starty, width, height);

   g.setPaintMode();

  }

}



/** waste some time - may fix netscape problem with threading*/



class TimeThread extends Thread {

 

  public void run() {

    while (true) {

       try { 

        sleep(5);

      } catch (Exception E) {

        stop();

      }

  }

 }

}