//
// FILE : ifs.java
//
// AUTHOR      : Generated automaticaly by Aleksey's automatic
//               source code generator:)   Novosibirsk, Russia 1999y
//
// DESCRIPTION : Self-similar fractals editor (IFS editor).
//               The last version of applet is able on the page
//                   http://chat.ru/~fractals/english.htm
//

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

//
// CLASS       : ifs
//
// DESCRIPTION : This class draws one of tree aviable zippers.
//
public final class ifs extends Applet implements Runnable, ItemListener, 
						ActionListener, MouseListener, MouseMotionListener
{
	private	Choice		examples;	// samples box
	private	Choice		it_box;		// iteration value box
	private	Checkbox	points_box;	// algoritm by points
	private	Checkbox	hide_first;	// hide first level lines
	private	Checkbox	refl_box;	// map reflection (conjugation) checkbox
	private	int			user_item;	// index of last choice box item
	private	Button		rev_button;	// reverse map button
	private	Button		add_button;	// add map button
	private	Button		del_button;	// delete map button
	private	Color		colors1[];	// colors to draw lines of the maps
	private	Color		colors2[];	// dark colors array to draw the fractal

	private int			px,py;		// last mouse pressed position
	private	boolean		dragged;	// on mouse dragged
	private	int			next_point;	// points to select if mouse not dragged
	private	final int	start_it=2;	// starting iteration value in it_box
	private	final int	flags = (MouseEvent.SHIFT_MASK|MouseEvent.ALT_MASK
						|MouseEvent.BUTTON2_MASK|MouseEvent.BUTTON3_MASK); 
							// disconnecting mouse flags

	private Thread	 the_thread;			// the thread of the drawing process
	private boolean	 corrupted;				// if there exist non contractive map
	private volatile boolean drawing;		// true if fractal must be redrawed
	private volatile boolean redraw_maps;	// if maps have to be repainted
	private volatile boolean suspended;		// current state of drawing thread

	private volatile Graphics	graph;		// current drawing place 
	private volatile Rectangle	cur_rect;	// current drawing rectangle
	private volatile Rectangle	next_rect;	// next drawing rectangle

	private int		maps_number;	// number of maps
	private int		seg_number;		// number of segments
	private int		points_number;	// number of points (=seg_number*2)
	private int		deep_of_tree;	// deep of lines tree (=-1 if is unused)
	private int		connected[];	// connected points (-1=not connected,-2=selected)
	private boolean	conjugated[];	// array of maps states (=true if conjugated)
	private boolean	reversed[];		// array of maps states (=true if reversed)

	private Point	points[];		// array of mooving points
	private int		hot_point;		// the first selected point of connected points
	private int		selected_point;	// (=-1 if no points selected)
	private int		selected_seg;	// (=-1 if no maps selected)
	private double	maps[][];		// calculated array of maps (6 numbers per every map)

	public void init(){
		stop_the_thread();	// start and suspend the thread

		setLayout(new FlowLayout());

		setBackground(Color.white);
		graph	 = getGraphics();
		graph.setPaintMode();
		cur_rect = graph.getClipBounds();

		examples	= new Choice();
		it_box		= new Choice();
		rev_button	= new Button("Reverse map");
		add_button	= new Button("Add map");
		del_button	= new Button("Delete map");
		refl_box	= new Checkbox("Reflection");
		points_box	= new Checkbox("By points");
		hide_first	= new Checkbox("Hide first");

		examples.addItem("Koch curve");
		examples.addItem("Sierpinsky triangle");
		examples.addItem("Dragon curve");
		examples.addItem("Levy curve");
		examples.addItem("Branch");
		examples.addItem("4 maps rectangle");
		examples.addItem("User ...");
		user_item = examples.getItemCount()-1;

		for(int i=start_it;i<=12;i++) it_box.addItem(Integer.toString(i));

		add(examples);
		add(it_box);
		add(hide_first);
		add(points_box);
		add(add_button);
		add(del_button);
		add(rev_button);
		add(refl_box);

		load_set(0);
		examples.addItemListener(this);
		it_box.addItemListener(this);
		hide_first.addItemListener(this);
		points_box.addItemListener(this);
		rev_button.addActionListener(this);
		add_button.addActionListener(this);
		del_button.addActionListener(this);
		refl_box.addItemListener(this);
		addMouseListener(this);
		addMouseMotionListener(this);
	}

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

		f.add("Center", the_applet);
		f.setSize(400, 400);
		f.show();
	}

	// information about fractal
/*	private String cur_map_info() {
		String s;
		s = "{"+maps_number+","+deep_of_tree+",";
		int cn=0,rv=0; // conjugation, reversing

		for(int i=0; i<points_number; i++) {
			s += points[i].x+","+points[i].y+",";
		}
		for(int i=0; i<seg_number; i++) {
			cn |= (conjugated[i]? 1<<i: 0);
			rv |= (  reversed[i]? 1<<i: 0);
		}		
		s += cn+","+rv+"}";
		return s;
	}*/

	// returns applet info
	public String getAppletInfo() {
		return  "Fractal drawing applet v2.0.\n"
				+ "  This simple applet allow to create self-similar fractals.\n"
				+ "  The last version of applet is aviable from the Web-page\n"
				+ "      http://chat.ru/~fractals/english.htm \n"
				+ "Novosibirsk Akademgorodok, Russia, 1999y\n";
//				+ cur_map_info();
	}

	public void destroy() {
		remove(examples);
		remove(it_box);
		remove(hide_first);
		remove(points_box);
		remove(add_button);
		remove(del_button);
		remove(rev_button);
		remove(refl_box);

//		stop_the_thread();	// stop drawinng (depricated now)
		the_thread.stop();	// stop the thread
		the_thread = null;	// delete the thread
	}

	public void paint(Graphics g)
	{
		// restart thread if it has dead for some reason
		if(!the_thread.isAlive()) stop_the_thread();

		// notify the parallel thread that rectangle is redrawing
		Rectangle r = g.getClipBounds();
		// if next task does not exists yet
		if(next_rect==null) next_rect=r;
			else next_rect.add(r);	// get union of rectangles

		// extend current task
		if(cur_rect!=null) {
			cur_rect.add(r);		// get union of rectangles
			graph.setClip(cur_rect);
		}

		// restart drawing if waiting for it
		if( suspended )
		{
			// next_rect!=null is notification for resuming the_thread
			the_thread.interrupt();
			Thread.yield();
		}
		
		// set redraw maps flag
		redraw_maps = true;
	}

	public void itemStateChanged(ItemEvent e){
		ItemSelectable item = e.getItemSelectable();
		// if item of list of examples is selected
		if(examples==item){
			int index = examples.getSelectedIndex();
			// if user item is selected then there is nothing to change
			if(index==user_item) return;
			load_set(index);
		} else if(it_box==item){
			// item of iteration number list is selected
			deep_of_tree = it_box.getSelectedIndex() + start_it;
		} else if(refl_box==item){
			// reflection combo box is checked
			// if no segment was selected then nothing to change
			if(selected_seg<0) return;
			conjugated[selected_seg] = refl_box.getState();
		} 
		
		// if(points_box==item)
		it_box.setEnabled(!points_box.getState());
		rebuild();
	}

	public void actionPerformed(ActionEvent e){
		Object o=e.getSource();
		// if reverse_map button is pressed
		if(rev_button==o){
			reversed[selected_seg] = !reversed[selected_seg];
			rebuild();
		} else if(add_button==o){
			//************************
			// add_map button pressed!
			//************************
			int i;		// loop counter
			Point	p[];
			int		c[];
			boolean	b[];
			boolean	r[];
			maps = new double[points_number+2][6];
			p = new Point[points_number+2];
			c = new   int[points_number+2];
			b = new boolean[seg_number+1];
			r = new boolean[seg_number+1];
			//  here (b[i]==r[i]==false) is obtained automaticaly
			disconnect(1);

			// copy maps states
			for(i=0; i<seg_number; i++) {
				b[i] = conjugated[i];
				r[i] = reversed[i];
			}

			// copy points and they connections
			for(i=0; i<points_number; i++) {
				p[i] = points[i];
				p[i].x = (p[i].x-20 )*maps_number/(maps_number+1) + 20;
				p[i].y = (p[i].y-200)*maps_number/(maps_number+1) + 200;
				c[i] = connected[i];
			}
			
			// here i==points_number
			p[i]   = new Point(p[i-1]);
			p[i+1] = new Point(380, p[i-1].y);
			p[1].setLocation(p[i+1]);
			c[i]   = hot_point_of(i-1);	// attach to the segment before the last
			c[i+1] = 1;				// detach from other segments

			stop_the_thread();
			maps_number++;		// increase maps   number
			seg_number++;
			points_number+=2;	// increase points number
			points		= p;
			connected	= c;
			conjugated	= b;
			reversed	= r;
			set_colors();
			examples.select(user_item);
			rebuild();	// process alrady has been stoped
		} else if(del_button==o && 2<maps_number
				&& 0<selected_seg && selected_seg<=seg_number){
			//***************************
			// delete_map button pressed! 
			//***************************			
			stop_the_thread();
			disconnect(selected_seg*2);
			disconnect(selected_seg*2+1);			
			select_point(-1);
			
			points_number-=2;
			maps_number--;
			seg_number--;
			// copy points and they connections
			for(int i=selected_seg; i<seg_number; i++) {
				conjugated[i] = conjugated[i+1];
				reversed[i]   = reversed[i+1];
			}

			// copy points and they connections
			for(int i=selected_seg*2; i<points_number; i++) {
				points[i] = points[i+2];
				connected[i] = connected[i+2]-((selected_seg*2)<connected[i+2]?2:0);
			}
			select_seg(-1);
			set_colors();
			examples.select(user_item);
			repaint();	// but not rebuild (process alrady has been stoped)
		}		
//		showStatus("IFS Editor: "+maps_number+" maps generated fractal");
	}

	public void mouseClicked(MouseEvent e){}
	public void mouseEntered(MouseEvent e){}
	public void mouseExited(MouseEvent e){}
	public void mouseMoved(MouseEvent e){}

	public void mousePressed(MouseEvent e)
	{
		px = e.getX();
		py = e.getY();
		dragged = false;
		next_point = find_point();

		// no object selected
		if(next_point<0) {
			select_seg(-1);
			select_point(-1);
//			return;  // don't consume event
		} else {
			// not current point selected
			if(next_point<points_number /*&& hot_point!=hot_point_of(n)*/) {
				if(hot_point!=hot_point_of(next_point))
					select_point(next_point);
			} else {
				// if map selected (points_number<=n)
				select_seg(next_point-points_number);
			}
			e.consume(); // consume the event		
		}		
		rebuild();
	}

	public void mouseReleased(MouseEvent e){
		if(dragged){
			// Ctrl pressed= acurate positioning
			if((e.getModifiers()&MouseEvent.CTRL_MASK)==0&&0<=hot_point){
				int r=30;       // nearest aviable distance
				int index=-1;   // its index
				// search for the neares point
				for(int i=0;i<points_number;i++) {
					if(connected[i]==-1&&i!=hot_point){
						int x=points[i].x-points[hot_point].x;
						int y=points[i].y-points[hot_point].y;
						if((x*x+y*y)<r){
							index=i;
							r=x*x+y*y;
						};
					}
				}
				if(index>=0){
					connect_current_to(index);
					rebuild();
				}
			}

			examples.select(user_item);
			dragged = false;
		} else {
			// if next point must be selected
			if(0<=next_point && next_point<points_number && 
				(next_point!=selected_point || (next_point/2)!=selected_seg)){
				select_point(next_point);
				select_seg(selected_point/2);
				e.consume(); // consume the event
				repaint();
			}
		}
	}

	/*private void on_point_dragged(int index){
		int hot = hot_point_of(index);
        for(int i=hot;i<points_number;i++)
            if(hot_point_of(i)==hot) points[i].setLocation(points[index]);
	}*/

    public void mouseDragged(MouseEvent e) {	
		int beg, end; // starting and last moving points
		int dx=-px, dy=-py;
		dx += (px=e.getX());
		dy += (py=e.getY());

		// if no point or segment selected
		if(next_point<0) {
			beg = 0;
			end = points_number-1;
		} else {
			// if a segment was selected
			if(next_point>=points_number){
				beg = selected_seg*2;
				end = beg+1;
			} else {
				// if a point was selected
				beg = end = selected_point;
			}
		}
		
		Rectangle r = getBounds();			// applet's rectangle
		
		// try to move all points of moving segments
		for(int i=beg; i<=end; i++) {
			points[i].translate(dx,dy);
			// if can't move the i-th point
			if(!r.contains(points[i])){
				 // restore coordinates
				while(i>=beg){
					points[i--].translate(-dx,-dy);
				}
				return;
			}
		}
		
		// if there is any selected point
		if(next_point>=0) {
			// if mouse dragging just has been started
			if((e.getModifiers()&flags)!=0 && !dragged){
				// disconnect moved points from other
				for(int i=end; i>=beg; i--) {
					disconnect(i);
				}
				hot_point = hot_point_of(selected_point);
			} else {
				// move points connected to already moved points
				for(int i=beg; i<=end; i++) {
					points[hot_point_of(i)].setLocation(points[i]);
				}

				// I think following loop have to be a function
				for(int i=0; i<points_number; i++) {
					points[i].setLocation(points[hot_point_of(i)]);
				}
			}
		}

		// try to restart drawing but not wait
		next_rect = null;			// notification: don't resume drawing
		drawing = false;			// notification: stop drawing
		dragged = true;


		e.consume(); // consume the event
		repaint();
	}

	private final void select_point(int index) {
		if(0<=hot_point&&hot_point<points_number) 
			connected[hot_point]=-1;        // select

		selected_point = index;
		hot_point = hot_point_of(selected_point);
	}

	private void select_seg(int index){
		selected_seg = (0<=index&&index<points_number) ? index : -1;
		boolean now = 0<selected_seg;

		// disable buttons if no segment selected
		rev_button.setEnabled(now);
		refl_box.setEnabled(now);
		refl_box.setState(now && conjugated[selected_seg]);
		del_button.setEnabled(now&&2<maps_number);
	}

	// return index of according drawed point
	private int hot_point_of(int index){
		if(0<=index&&index<points_number){
			if(0<=connected[index] && connected[index]<points_number)
				return connected[index];
			return index;
		}
		return -1;	// if index is not a point number
	}

	// disconnect the i-th point from other
	private void disconnect(int i) {		
		// if the i-th point is the hot_point
		if(connected[i]<0){
			// find first point connected to the i-th
			for(int j=i+1; j<points_number; j++){
				if(i==connected[j]){
					for(int k=j+1;k<points_number;k++) {
						if(i==connected[k]) connected[k]=j;
					}
					connected[j]=-1;
					break;
				}
			}
		}
		connected[i]=-1;
		//System.out.println("disconnect("+i+")");
	}
    
    private void connect_current_to(int index){
        index = hot_point_of(index);
        if(hot_point<0||index<0||index==hot_point) return;

        // copy coordinates
        for(int i=hot_point+1;i<points_number;i++){
			if(connected[i]==hot_point) points[i].setLocation(points[index]);
        }
        points[hot_point].setLocation(points[index]);

        // exchange indexes
        if(index<hot_point){
            int h=hot_point;
            hot_point=index;
            index=h;
        }
        connected[index]=hot_point;
        connected[hot_point]=-2;

        // reconnect other points
        for(int i=index+1;i<points_number;i++){
            if(connected[i]==index) connected[i]=hot_point;
		}
    }

	// check that point[index] is selected
    private final boolean check_point(int index){
		return (Math.abs(px-points[index].x)<=4 && Math.abs(py-points[index].y)<=4);
    }

	// check that line is selected
	private final boolean check_line(Point org,Point vect){
		int x=px-org.x, y=py-org.y, vx=vect.x-org.x, vy=vect.y-org.y;
		return ( (vx*x+vy*y)>0 && (vx*(vx-x)+vy*(vy-y))>0 &&
			Math.abs(vy*x-vx*y)<(Math.sqrt(vx*vx+vy*vy)*3) );
    }

	// find selected object
    private final int find_point(){
		int i;	// loop counter
		int n=0;
		// if end of current segment was selected
		if(0<=selected_seg && (check_point(n=selected_seg*2) || check_point(++n)))
			select_point(n);
		
		// find next point to select
		for(i=1; i<=points_number && !check_point(n=(i+selected_point)%points_number); i++);
        if(i<points_number) return n;
		
		// find line to select, if no suitable points was found
        for(i=0; i<points_number&&(!check_line(points[i],points[i+1])); i+=2);
        if(i<points_number) return i/2+points_number;   // selected map
        return -1;
    }

	// calculate colors of maps
    private final void set_colors(){
        colors1 = new Color[seg_number];
        colors2 = new Color[seg_number];
		colors1[0] = new Color(230,230,230);

        // fill color arrays
        for(int i=0; i<maps_number; i++){
                float h = i/(float)maps_number;
                colors1[i+1] = Color.getHSBColor(h, 0.9f, 0.99f);
                colors2[i]   = Color.getHSBColor(h, 0.9f, 0.70f);
        }
    }

    private final void calculate_maps(){
        corrupted = false;

		int x  = points[0].x;
		int y  = points[0].y;
		int vx = points[1].x-x;
		int vy = points[1].y-y;
//        int vx = points[points_number-1].x-x;
//        int vy = points[points_number-1].y-y;
        
        double r2 = vx*vx+vy*vy;
        if(r2==0) return; // can't calculate any map

        // calculate matrises and shifts of each map
        for(int i=0; i<maps_number; i++){
			int f1 = points[i*2+3].x-points[i*2+2].x;
			int f2 = points[i*2+3].y-points[i*2+2].y;
			// check: is the current map a contraction?
			if((f1*f1+f2*f2)>=r2) corrupted=true;

			if(  reversed[i+1]) { f1=-f1; f2=-f2; }
			if(conjugated[i+1]) {
				maps[i][0] = (vx*f1-vy*f2)/r2;
				maps[i][2] = (vx*f2+vy*f1)/r2;
			} else {
				maps[i][0] = (vx*f1+vy*f2)/r2;
				maps[i][2] = (vx*f2-vy*f1)/r2;
			}

			maps[i][1] = (conjugated[i+1]? maps[i][2] :-maps[i][2]);
			maps[i][3] = (conjugated[i+1]?-maps[i][0] : maps[i][0]);

			// A*z+b=w & A*(z-e)+f=w  ==>  b=f-A*e
			f1 = points[i*2+(reversed[i+1]?3:2)].x;
			f2 = points[i*2+(reversed[i+1]?3:2)].y;
			maps[i][4] = f1-maps[i][0]*x-maps[i][1]*y;
			maps[i][5] = f2-maps[i][2]*x-maps[i][3]*y;
        }
    }

	private void draw_maps(){
		redraw_maps = false;
		int i;					// loop counter
		
		// loop by points
		for(i=0;i<points_number;i+=2) {
			graph.setColor(colors1[i/2]);

			// if not lines are not hided 
			if(!hide_first.getState())
				graph.drawLine(points[i].x,points[i].y,points[i+1].x,points[i+1].y);
			// if current map is selected
			if( i==(selected_seg*2) ) {
				int x = (points[i].x<points[i+1].x)? -1 : 1;    // sign
				int y = (points[i].y<points[i+1].y)? -1 : 1;

				graph.drawLine( points[i].x-y,  points[i].y+x,
						points[i+1].x-y,points[i+1].y+x );
				graph.drawLine( points[i].x+y,  points[i].y-x,
						points[i+1].x+y,points[i+1].y-x );
			}
		}

		graph.setColor(Color.blue);
		// draw points
		for(i=0;i<points_number;i++){
			if(connected[i]<0){
				int h = (i==hot_point)? 3 : 2;
				graph.drawRect(points[i].x-h,points[i].y-h,h+h,h+h);
			}
        }
	}

	private void draw_curve(Color[] colors, int it){
		int n = maps_number;
        int m[];                // array of counters
        m  = new int[100];		// allocate to upper limit
		double p[][] = new double[4][100];	// coordinates of the first  point

		p[0][0] = points[0].x;
		p[1][0] = points[0].y;
		p[2][0] = points[1].x;
		p[3][0] = points[1].y;

        // drawing curve by lines cicle
		for(int l=0; drawing;)
		{
			if(redraw_maps) draw_maps();

            // jump to last map
			for(l++; l<=it && drawing; l++){
				m[l]=n-1;
				p[0][l]=maps[n-1][0]*p[0][l-1]+maps[n-1][1]*p[1][l-1]+maps[n-1][4];
				p[1][l]=maps[n-1][2]*p[0][l-1]+maps[n-1][3]*p[1][l-1]+maps[n-1][5];
				p[2][l]=maps[n-1][0]*p[2][l-1]+maps[n-1][1]*p[3][l-1]+maps[n-1][4];
				p[3][l]=maps[n-1][2]*p[2][l-1]+maps[n-1][3]*p[3][l-1]+maps[n-1][5];
			}

            if(drawing) {
				graph.setColor(colors[m[it]]);
				graph.drawLine((int)p[0][it],(int)p[1][it],(int)p[2][it],(int)p[3][it]);
			} else return;
			

            // decrease map number
            while( (--l)>0 && (m[l]--)==0 );
            if(l<=0)break;

			// jump to next way
            int c=m[l];
            p[0][l]=maps[c][0]*p[0][l-1]+maps[c][1]*p[1][l-1]+maps[c][4];
            p[1][l]=maps[c][2]*p[0][l-1]+maps[c][3]*p[1][l-1]+maps[c][5];
            p[2][l]=maps[c][0]*p[2][l-1]+maps[c][1]*p[3][l-1]+maps[c][4];
            p[3][l]=maps[c][2]*p[2][l-1]+maps[c][3]*p[3][l-1]+maps[c][5];
        }
    }

	private void draw_points(Color[] colors){
        int x = points[0].x;
		int y = points[0].y;
		double r = maps_number-(1e-9);

		// main drawing circle
		for(;drawing;){
			if(redraw_maps) draw_maps();

			int i=(int)(Math.random()*r);
            int z = (int)(maps[i][0]*x+maps[i][1]*y+maps[i][4]);
            y = (int)(maps[i][2]*x+maps[i][3]*y+maps[i][5]);
			x = z;
            if(drawing) {
				graph.setColor(colors[i]);
				graph.drawLine(x,y,x,y);
			}
        }
    }

    public void run(){
		// main cicle
		for(;;) {
			// suspend cicle (waiting for new drawing task)
			while(next_rect == null){
				suspended = true;
				// sleep for 0.1 second
				try{
					Thread.sleep(100);
				} catch(InterruptedException e){}
			}

			try{				
				cur_rect = next_rect;	// consume drawing task
				next_rect = null;		// clear future tasks
				drawing	= true;			// set drawing flag
				redraw_maps = true;		// redraw maps flag
				suspended = false;		// thread was resumed

				graph.setClip(cur_rect);
				if(redraw_maps) draw_maps();

				if(drawing) calculate_maps();

				if(!corrupted && drawing) {
					if(points_box.getState()) draw_points(colors2);
					else draw_curve(colors2,deep_of_tree);
				}
			} catch(Exception e) {
				showStatus("Exeption while drawing: "+e);
			};
		}
    }

    private void stop_the_thread(){
		drawing = false;	// notification to stop drawing
		next_rect = null;	// notification don't resume drawing

		// start thread if its does not exist yet
		if(the_thread==null || !the_thread.isAlive()){
			the_thread = new Thread(this);
			the_thread.setPriority(Thread.MAX_PRIORITY);
			the_thread.start();
		}

		// wait for the other thread
		for(int i=1; i<=10 && !suspended;i++){
			Thread.yield();
			try{ if(!suspended) Thread.sleep(100); } 
			catch(InterruptedException e){};
		}
		
//		for(int i=0; i<100 && !suspended; i++) Thread.yield();

		// debuging
//		if(!suspended) {
//			System.out.println("Not suspended in stop_the_thread()! "+the_thread);
//			System.out.println("the_thread.isAlive()="+the_thread.isAlive());
//			showStatus("Mmm... Not suspended!"+the_thread);
//		}
	}

	private final void rebuild(){
		stop_the_thread();
		repaint();
	}

    // number of sets, best deep_of_tree, (x1,y1,x2,y2...), conjugation, reversing
    private final int example_sets[][] = {
            {2,6, 20,250,380,250,  20,250,200,130, 200,130,380,250, 6, 0},	// Koch
            {3,5, 20,380,380,380,  20,380,110,224, 
				 110,224,290,224, 290,224,380,380,  10, 0},					// Sierpinsky
            {2,6,100,250,300,250, 100,250,200,150, 200,150,300,250, 0, 4},	// Dragon
            {2,8,100,150,300,150, 100,150,200,250, 200,250,300,150, 0, 0},	// Levy
            {2,8, 20,250,380,250,  20,250,200,130, 152,250,380,250, 6, 0},	// White willow branch
            {4,5, 80,280,320,280,  80,280, 80,182,  80,182,200,182,
                 200,182,320,182, 320,182,320,280,  18,0}					// 4 map rectangle
//----------------------------------------------------------------------------------
//          {4,4, 20,250,110,250, 110,250,200,250,
//               200,250,290,250, 290,250,380,250, 0, 0}	// 4 segments
    };

	void load_set(int n){
		stop_the_thread();

		maps_number   = example_sets[n][0];
		seg_number    = maps_number+1;
		points_number = seg_number*2;
		deep_of_tree  = example_sets[n][1];
		selected_point= -1;     // deselect point
		hot_point     = -1;     // deselect point

		points			= new Point[points_number];
		connected		= new   int[points_number];
		conjugated		= new boolean[seg_number];
		reversed		= new boolean[seg_number];
		maps			= new double[points_number][6];
		set_colors();		// fill color arrays
		it_box.select(deep_of_tree-start_it);
		int i,j;

		for( i=2,j=0; j<points_number; j++,i+=2 ){
			points[j] = new Point( example_sets[n][i], example_sets[n][i+1] );

			connected[j]=-1;        // deselect point
			for(int k=0;k<j;k++) {
				if(points[k].equals(points[j])) {
					connected[j]=k;
					break;
				}
			}
		}

		for(j=0; j<seg_number; j++ ) {
			conjugated[j] = ((example_sets[n][i  ]>>j)&1) != 0;
			reversed[j]   = ((example_sets[n][i+1]>>j)&1) != 0;
		}
		select_seg(-1);         // deselect any map	
		showStatus("IFS Editor: "+maps_number+" maps generated fractal");

		repaint();
	}
}