// Variabelen waarmee de instellingen van het
// kleur-wissel-script kunnen worden aangepast.
scale = 10;							// Subtiliteit waarmee de kleuren wisselen
color_delay = 50;					// Vertraging tussen twee stappen in msec
									// (>50!)
rows = 19;							// Aantal rijen
columns = 7;						// Aantal kolommen
scale_columns = 7;					// Aantal kolommen voor de schaal
cycle_count = 0;					// Timer
continue_cycle = true;				// Doorgaan met kleuren wisselen
last_red = 0;						// Laatste kleur rood
last_green = 0;						// Laatste kleur groen
last_blue = 0;						// Laatste kleur blauw
color_x_offset = 0;					// De x offset van de kleur
color_y_offset = 0;					// De y offset van de kleur
agenda_item = 0;					// Het gekozen item
current_square = new Object();		// Het huidige object waar over "gehovered"
									// wordt
hover_color = 'rgb(204, 204, 204)';	// De achtergrond kleur wanneer er op een
									// square wordt gehovered
blocks = new Array();				// De pointers naar alle elementen



/**
 * Functie: Initialiseren van de blokken in een array om te voorkomen dat er
 * teveel DOM-lookups gebeuren
 */
function initializeBlocks()
{
	// Maak de arrays aan
	for (i=0; i<rows; i++)
	{
		blocks[i] = new Array();
	}

	// Vul de array's
	for (i=0; i<rows; i++)
	{
		for (j=0; j<columns; j++)
		{
			blocks[i][j] = document.getElementById('block'+i+'_'+j);
		}
	}
}



/**
 * Functie: Het wisselen van kleuren en dit blijven herhalen
 */
function cycleColors(start_cycle)
{
	var blocks_local = blocks;

	// Geef de rijen de goede kleur
	for (i=0; i<rows; i++)
	{
		for (j=0; j<columns; j++)
		{
			switch (current_square.id)
			{
				case 'block'+i+'_'+j:
					blocks_local[i][j].style.backgroundColor = hover_color;
					break

				default:
					blocks_local[i][j].style.backgroundColor = calculateColor(j, i, cycle_count, color_y_offset);
					break;
			
			}
		}
	}

	// Ga door het het circuleren
	if (continue_cycle && start_cycle) {
		cycle_count++;
		window.setTimeout("cycleColors(true)",color_delay);
	}
}



/**
 * Functie: Bereken de achtergrondkleur van een vak aan de hand van de
 * coordinaten binnen de matrix en de offset (welke bepaald wordt door de tijd
 * die het script loopt).
 * Parameter: x - De x-positie binnen de matrix
 * Parameter: y - De y-positie binnen de matrix
 * Parameter: x_offset - Het nummer van de offset waarmee begonnen moet worden
 *                       (beginnen met rood i.p.v. geel)
 * Parameter: y_offset - Het cyclenummer
 */
function calculateColor(x, y, x_offset, y_offset)
{
	y = (y+y_offset) % rows;
	step = y/rows;
	color = Math.floor(step*4);

	switch (color)
	{
		// Geel naar rood
		case 0:
			red = 255;
			green = parseInt(255-((step*4)*255));
			blue = parseInt(((scaleFunction((x*scale)+x_offset, (scale_columns*scale)))/(scale_columns*scale))*255);
			last_red = red;
			last_green = green;
			last_blue = blue;
			return 'rgb('+red+','+green+','+blue+')';

		// Rood naar zwart
		case 1:
			step = step - (1/4);
			red = parseInt(255-((step*4)*255));
			green = 0;
			blue = parseInt(((scaleFunction((x*scale)+x_offset, (scale_columns*scale)))/(scale_columns*scale))*255);
			last_red = red;
			last_green = green;
			last_blue = blue;
			return 'rgb('+red+','+green+','+blue+')';
			break;

		// Zwart naar groen
		case 2:
			step = step - (2/4);
			red = 0
			green = parseInt((step*4)*255);
			blue = parseInt(((scaleFunction((x*scale)+x_offset, (scale_columns*scale)))/(scale_columns*scale))*255);
			last_red = red;
			last_green = green;
			last_blue = blue;
			return 'rgb('+red+','+green+','+blue+')';
			break

		// Groen naar geel
		case 3:
			step = step - (3/4);
			red = parseInt((step*4)*255);
			green = 255;
			blue = parseInt(((scaleFunction((x*scale)+x_offset, (scale_columns*scale)))/(scale_columns*scale))*255);
			last_red = red;
			last_green = green;
			last_blue = blue;
			return 'rgb('+red+','+green+','+blue+')';
			break;
	
	}
}



/**
 * Functie: Bereken het nummer aan de hand van de schaal, waarbij y = x wanneer
 * y kleiner is dan de scale en return y = scale-x wanneer de y groter is dan
 * de scale
 * Parameter: number = De x co-ordinaat
 * Parameter: scale = De schaal waarbinnen de x valt
 */
function scaleFunction(number, scale)
{	
	step = number%(scale*2);
	if(step > scale) {
		return scale-(step-scale);
	} else {
		return step;
	}
}



/**
 * Functie: Het berekenen van de tekstkleur aan de hand van de
 * meegegeven RGB kleur van de achtergrond
 * Parameter: red - De R waarde van de RGB kleur
 * Parameter: green - De G waarde van de RGB kleur
 * Parameter: blue - De B waarde van de RGB kleur
 */
function calculateTextColor(red, green, blue, inverted)
{
	// Kijk of wit een geschikte kleur is
	brightness_white = 255;
	brightness_color = getColourBrightness(red, green, blue);
	color_difference_white = getColourDifference(255, red, 255, green, 255, blue);
	if ((brightness_white - brightness_color) > 200) {
		if (!inverted) {
			return 'rgb(255, 255, 255)';
		} else {
			return 'rgb(0, 0, 0)';
		}
	}

	// Kijk of zwart een geschikte kleur is
	brightness_black = 0;
	brightness_color = getColourBrightness(red, green, blue);
	color_difference_black = getColourDifference(0, red, 0, green, 0, blue);
	if ((brightness_color - brightness_black) > 200) {
		if (!inverted) {
			return 'rgb(0, 0, 0)';
		} else {
			return 'rgb(255, 255, 255)';
		}
	}
}



/**
 * Functie: Het berekenen van de 'brightness' aan de hand van
 * de meegegeven RGB waarden
 * Parameter: red - De R waarde van de RGB kleur
 * Parameter: green - De G waarde van de RGB kleur
 * Parameter: blue - De B waarde van de RGB kleur
 */
function getColourBrightness(red, green, blue)
{
	return ((red * 299) + (green * 587) + (blue * 114)) / 1000;
}



/**
 * Functie: Het berekenen van het kleurverschil tussen twee
 * kleuren aan de hand van de W3C specificaties
 * Parameter: red1 - De R waarde van de 1e RGB kleur
 * Parameter: red2 - De R waarde van de 2e RGB kleur
 * Parameter: green1 - De G waarde van de 1e RGB kleur
 * Parameter: green2 - De G waarde van de 2e RGB kleur
 * Parameter: blue1 - De B waarde van de 1e RGB kleur
 * Parameter: blue2 - De B waarde van de 2e RGB kleur
 */
function getColourDifference(red1, red2, green1, green2, blue1, blue2)
{
	return (Math.max(red1, red2) - Math.min(red1, red2)) + (Math.max(green1, green2) - Math.min(green1, green2)) + (Math.max(blue1, blue2) - Math.min(blue1, blue2));
}



/**
 * Functie: Haal de kleur op van het meegegeven object. Ook
 * wordt het cyclen gestopt.
 * Parameter: obj - Het object waarvan de kleur wordt opgehaald
 */
function getColor(obj) {
	continue_cycle = false;
	return splitColor(obj.style.backgroundColor, 'red').toString(16)+splitColor(obj.style.backgroundColor, 'green').toString(16)+splitColor(obj.style.backgroundColor, 'blue').toString(16);
}



/**
 * Functie: Splits de CSS kleuren in integers. Een voorbeeld
 * hiervan is het splitsen van rgb(0, 128, 255) in de waarden
 * 0 voor rood, 128 voor groen en 255 voor blauw.
 * Parameter: color - De css kleur die gesplitst moet worden
 * Parameter: return_type- De kleur die terug gegeven moet worden
 */
function splitColor(color, return_type)
{
	color = color.substring(4, color.length-1);
	color_array = color.split(',');
	if (return_type == 'red') {
		return parseInt(color_array[0]);
	} else if (return_type == 'green') {
		return parseInt(color_array[1]);
	} else if (return_type == 'blue') {
		return parseInt(color_array[2]);
	}
}



/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * "gehighlight" wordt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function highlightSquare(obj)
{
	current_square = obj;
	obj.style.backgroundColor = 'rgb(204, 204, 204)';
	cycleColors(false);
}

/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * "gehighlight" wordt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function highlightSquareIE()
{
	if (event.srcElement.tagName == 'A') {
		obj = event.srcElement.parentNode.parentNode;
	} else if (event.srcElement.tagName == 'P') {
		obj = event.srcElement.parentNode;
	} else {
		obj = event.srcElement;
	}
	current_square = obj;
	obj.style.backgroundColor = 'rgb(204, 204, 204)';
	cycleColors(false);
}



/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * terug in de shadow komt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function shadowSquare(obj)
{
	current_square = new Object();
	obj.style.backgroundColor = 'inherit;';
	cycleColors(false);
}



/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * terug in de shadow komt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function shadowSquareIE()
{
	if (event.srcElement.tagName == 'A') {
		obj = event.srcElement.parentNode.parentNode;
	} else if (event.srcElement.tagName == 'P') {
		obj = event.srcElement.parentNode;
	} else {
		obj = event.srcElement;
	}
	current_square = new Object();
	obj.style.backgroundColor = 'rgb(255, 255, 255)';
	cycleColors(false);
}



/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * terug in de shadow komt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function clickSquare(obj)
{
	createCookie('cycle_count',cycle_count, 1);
	continue_cycle = false;

	if (obj.tagName == 'DIV') {
		window.location.href = obj.getElementsByTagName('A')[0].href;
	}
}



/**
 * Functie: Verander de kleur van de tekst in een object wanneer dit object
 * terug in de shadow komt.
 * Parameter: obj- Het object waar de kleurverandering op toegepast moet worden
 */
function clickSquareIE()
{
	createCookie('cycle_count',cycle_count, 1);
	continue_cycle = false;

	if (event.srcElement.tagName == 'A') {
		window.location.href = event.srcElement.href;
	} else if (event.srcElement.tagName == 'P') {
		window.location.href = event.srcElement.childNodes[1].href;
	} else if (event.srcElement.tagName == 'DIV') {
		window.location.href = event.srcElement.getElementsByTagName('A')[0].href;
	} else if (event.srcElement.tagName == 'IMG') {
		window.location.href = event.srcElement.parentNode.href;
	} else {
		//
	}
}



/**
 *
 */
function addActions()
{
	all_divs = document.getElementsByTagName('div');
	for(i=0; i<all_divs.length; i++) {
		if (all_divs[i].className == 'column_text' || (all_divs[i].className == 'column_link' && all_divs[i].id.substr(0,5) == 'block'))
		{
			if (document.all) {
				all_divs[i].attachEvent('onmouseover', highlightSquareIE);
				all_divs[i].attachEvent('onmouseout', shadowSquareIE);
				all_divs[i].attachEvent('onclick', clickSquareIE);
			} else {
				all_divs[i].setAttribute('onmouseover','highlightSquare(this)');
				all_divs[i].setAttribute('onmouseout','shadowSquare(this)');
				all_divs[i].setAttribute('onclick','clickSquare(this)');
			}
		}
	}
}