/*
 * MindSundew.java
 * 
 * Ajatuskihokkipurkkaviritys GZZ 0.6.X:lle.
 * Mindmap scribble for GZigZag 0.6.X.
 *
 * @author asko.soukka@iki.fi
 *
 * Copyright (C) 2001 Asko Soukka, based on CompassView.java by Tuukka Hastrup
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * See the LICENSE.lgpl for the specific terms of the license.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 */

package org.gzigzag.module;

import org.gzigzag.*;
import java.awt.Dimension;
import java.lang.Math;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.util.Vector;

class MindSundew implements FlobView, ZOb { 
	
	public static final String rcsid = "$Id: MindSundew.java,v 1.1.2.1 2002/02/16 15:19:25 tuukkah Exp $";
	private int level = 0;
	private int levelA = 0;
	private int levelB = 0;

	public MindSundew() {}
	public String readParams(ZZCell c) { return null; };
	
	public void raster(FlobSet into, FlobFactory fact, ZZCell view, 
		String[] dims, ZZCell accursed) {

		/* ---- alustetaan kaikenlaista                    ---- */
//    FlobDecorator linker = new StdLinks();
		ZZCell stdim = ZZCursorReal.get(view.s("d.dims", 1));

		Dimension d = into.getSize();
                int midx = d.width / 2;
                int midy = d.height / 2;
		Dimension c = fact.getSize(null, 1);
		int cw = c.width;
		int ch = c.height;

    ZZUtil.showFlobDims(into, fact, view, 3);
		/* ---------------------------------------------------- */

		/* ---- piirretään ulottuvuuksien värit ylänurkkaan ---- */
		LineDecor.Builder line1 = new LineDecor.Builder(into, Color.black);
		LineDecor.Builder line2 = new LineDecor.Builder(into, Color.gray);
		LineDecor.Builder line3 = new LineDecor.Builder(into, Color.yellow);

		line1.startl(4, 1);
		line2.startl(4, 1);
		line3.startl(4, 1);

		line1.l(c.width/2, c.height/2, c.width*2, c.height/2);
		line2.l(c.width/2, c.height/2, c.width/2, c.height*2);
		line3.l(c.width/2, c.height/2, c.width*2, c.height*2);
	
		line1.endl();
		line2.endl();
		line3.endl();
		/* ---------------------------------------------------- */

		/* ---- kutsutaan ensimmäistä piirtokierrosta      ---- */
		drawLevel(into, fact, dims, accursed, d, c, stdim, midx, midy, cw, ch);
		//linker.decorate(into, "", view);
		/* ---------------------------------------------------- */

	}

	private void drawLevel(FlobSet into, FlobFactory fact, String[] dims, ZZCell accursed,
		Dimension d, Dimension c, ZZCell stdim, int midx, int midy, int cw, int ch) {

		/* ---- asetetaan piirtokierroksen tasokohtaiset   ---- */
		level++;
		float kerroin = 1; // käytetään solujen piirtokoossa
		if (level > 1) {
			kerroin = (float)0.7;
			for (int i=2; i<level; i++) 
				kerroin = kerroin * kerroin;
		}
		/* ---------------------------------------------------- */

		/* ---- alustetaan piirtokierroksen jutut          ---- */
		Vector cells = new Vector(); // Cells to positive directions to be drawn
	 	ZZCell dim, tc, top;
		top = null;
		dim = stdim;
		/* ---------------------------------------------------- */

		/* ---- haetaan kierroksella piirrettävät solut    ---- */
		cells.addElement(accursed);
		top = accursed.s(dims[0], -1);
		int i = 1;
		do {
			tc = accursed.s(dims[1], i++);
			if(tc != null && tc != accursed) {
				cells.addElement(tc);
				if (top == null) top = tc.s(dims[0], -1);
			}
			else break;
		} while (true);
		i = -1;
		do { tc = accursed.s(dims[1], i--); } while (tc != null && tc != accursed);
		if (tc == null) {
			i += 2;
			do {
				tc = accursed.s(dims[1], i++);
				if(tc != null && tc != accursed) {
					cells.addElement(tc);
					if (top == null) top = tc.s(dims[0], -1);
				}
				else break;
			} while (true);
		}
		if(cells.size() == 0) return; // No cells to draw
		/* ---------------------------------------------------- */

		/* ---- ympyrän laskemiseen tarvittavia juttuja    ---- */
		double angle = 2 * Math.PI / (cells.size());
		int l = (int) ((d.height < d.width ? d.height : d.width)
			/ 2 * 0.47 * kerroin * kerroin ); // syvyystasojen etäisyys ja säde
		double a = (double) 1.95 * Math.PI; // Begin placing positive cells top left
		/* ---------------------------------------------------- */

		/* ---- viivapiirtureiden alustus                  ---- */
		LineDecor.Builder line1 = new LineDecor.Builder(into, Color.black);
		LineDecor.Builder line2 = new LineDecor.Builder(into, Color.gray);
		LineDecor.Builder line3 = new LineDecor.Builder(into, Color.yellow);
		line1.startl(cells.size()*4, 12);
		line2.startl(cells.size()*4, 12);
		line3.startl(cells.size()*4, 12);
		/* ---------------------------------------------------- */

		/* ---- solujen piirto ja uusien kierrosten käynnistys- */
		i = 0;
		while (i < cells.size()) {
			int dx = x(a, l);
			int dy = y(a, l);

			if(cells.elementAt(i)!=null) {

/*				// ensimmäinen yläkäsite piirretään isolla, muuta tasokohtaisesti
				if (levelA == 1 && (ZZCell)cells.elementAt(i) == accursed)
					fact.centerFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						(float)1.1, new java.awt.Point(midx + dx-cw/2, midy+dy-ch/2), 0, 0, 1);
				else if (levelB != 1)
					fact.centerFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						kerroin, new java.awt.Point(midx + dx-cw/2, midy+dy-ch/2), 0, 0, level * level);
				else 
					fact.centerFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						kerroin, new java.awt.Point(midx + dx-cw/2, midy+dy-ch/2), 0, 0, level); */

				// ensimmäinen yläkäsite piirretään isolla, muuta tasokohtaisesti
				if (levelA == 1 && (ZZCell)cells.elementAt(i) == accursed)
					fact.makeFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						(float)1.1, midx + dx-cw/2, midy+dy-ch/2, 1, cw, ch);
				else if (levelB != 1)
					fact.makeFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						kerroin, midx + dx-cw/2, midy+dy-ch/2, level*level,	(int)(cw * kerroin), (int)(ch * kerroin));
				else 
					fact.makeFlob(into, (ZZCell)cells.elementAt(i), (ZZCell)cells.elementAt(i),
						kerroin, midx + dx-cw/2, midy+dy-ch/2, level,	(int)(cw * kerroin), (int)(ch * kerroin));

				// jos ei olla piirtämässä alakäsitteitä, käynnistetään piirto löydetylle yläkäsitteelle
				if (((ZZCell)cells.elementAt(i)).s(dims[0], -1) == top
						&& level < 3 && top != null && levelB == 0) {
					levelA++;
					line1.l(midx + dx-cw/2, midy+dy-ch/2, midx-cw/2, midy-ch/2);
					drawLevel(into, fact, dims, top, d, c, stdim, midx, midy, cw, ch);
					levelA--;
				}

				// jos ei olla piirtämässä yläkäsitteitä, käynnistetään piirto löydetylle alakäsitteelle
				if (((ZZCell)cells.elementAt(i)).s(dims[0], 1) != null &&  level < 3 && levelA == 0) {
					levelB++;
					line1.l(midx + dx-cw/2, midy+dy-ch/2, (int)(midx + (dx)*(1/kerroin)*2/level-cw/2),
						(int)(midy + (dy)*(1/kerroin)*2/level-ch/2));
					if (level < 2)
						drawLevel(into, fact, dims, ((ZZCell)cells.elementAt(i)).s(dims[0], 1), d, c, stdim,
							(int)(midx + (dx)*(1/kerroin)*2/level), (int)(midy + (dy)*(1/kerroin)*2/level), cw, ch);
					levelB--;
				}

				// käynnistetään piirto löydetylle sivuttaislinkitykselle
				if ((ZZCell)cells.elementAt(i) == accursed &&
					 ((ZZCell)cells.elementAt(i)).s(dims[2], -1) != null && level == 1) {
					line3.l(midx + dx-cw/2, midy+dy-ch/2, (int)(d.width / 10)+cw+cw/8, (int)(d.height / 10));
//					line3.l(midx + dx-cw/2, midy+dy-ch/2, (int)(d.width / 10)+cw/2, (int)(d.height / 10)+ch/2);
					drawLevel(into, fact, dims, ((ZZCell)cells.elementAt(i)).s(dims[2], -1), d, c, stdim,
						(int)(d.width / 10)+cw, (int)(d.height / 10)+ch, cw, ch);
				}
				if ((ZZCell)cells.elementAt(i) == accursed &&
					 ((ZZCell)cells.elementAt(i)).s(dims[2], 1) != null && level == 1) {
					line3.l(midx + dx-cw/2, midy+dy-ch/2, (int)(d.width * 9/10)+cw/4,
						(int)(d.height * 9/10));
//					line3.l(midx + dx-cw/2, midy+dy-ch/2, (int)(d.width * 9/10)-cw/2,
//						(int)(d.height * 9/10)-ch/2);
					drawLevel(into, fact, dims, ((ZZCell)cells.elementAt(i)).s(dims[2], 1), d, c, stdim,
						(int)(d.width * 9/10), (int)(d.height * 9/10), cw, ch);
				}
			}

			// siirrytään ympyrän kehällä eteenpäni
			a += angle; // Rotate clockwise

			// jos solusta on jatke eteenpäin (täytynee olla kehällä), piirretään viiva
			if (cells.elementAt(i)!=null && levelB < 2)		
				if (((ZZCell)cells.elementAt(i)).s(dims[1], 1) != null)
					line2.l(midx + dx-cw/2,	midy+dy-ch/2, midx + x(a, l)-cw/2, midy+y(a, l)-ch/2);

			// seuraava solu jonossa
			i++;
		}
		/* ---------------------------------------------------- */

		/* ---- piirtureiden lopetus ja tason lasku       ----- */
		line1.endl();
		line2.endl();
		line3.endl();
		level--;
		/* ---------------------------------------------------- */
  }

	protected int x(double angle, int length) {
		return (int)(Math.cos(angle) * length);
	} 
		
	protected int y(double angle, int length) {
		return (int)(Math.sin(angle) * length);
	}
}