function LegendEdit(name, form)
{
	var		layers, item;


	this.form		= form;
	this.hash		= new Hash();
	this.layer		= new Array();
	this.image		= new Array();
	this.display	= new Array();
	this.filter		= new Array();
	this.name		= new Array();
	this.label		= new Array();

	LegendEdit.prototype.setDrawOrder		= LegendEdit_setDrawOrder;
	LegendEdit.prototype.changeDrawOrder	= LegendEdit_changeDrawOrder;
	LegendEdit.prototype.enableDrawOrder	= LegendEdit_enableDrawOrder;
	LegendEdit.prototype.deleteDrawOrder	= LegendEdit_deleteDrawOrder;
	LegendEdit.prototype.changeLayerImage	= LegendEdit_changeLayerImage;

	LegendEdit.prototype.getValue			= LegendEdit_getValue;
	LegendEdit.prototype.setValue			= LegendEdit_setValue;
	LegendEdit.prototype.getKeys			= LegendEdit_getKeys;

	LegendEdit.prototype.update				= LegendEdit_update;


	for(item = 0; item < form.elements.length; item++)
	{
		element = form.elements[item];

		if(element.name.substring(0, 9) == "sequence_")
			this.hash.setValue(element.name, element.value);
	}

}

function LegendEdit_getValue(token)
{
	return(this.hash.getValue(token));
}

function LegendEdit_setValue(token, value)
{
	return(this.hash.setValue(token, value));
}

function LegendEdit_getKeys()
{
	return(this.hash.getKeys());
}


function LegendEdit_changeLayerImage(layer, image)
{
	var		element, image_object;

	if(image)
	{
		// An image has been specified.

		image_object = imageByName("image_" + layer);

		if(image_object == null)
		{
			alert("Unknown image 'image_" + layer + "'");
		}
		else
		{
			image_object.src = image;
			this.hash.setValue("image_" + layer, image);
		}

		//element = elementByName(form, "image_" + layer);
		//element.value = image;
	}
	else
	{
		popup = window.open("/demos/legend/select_image.html", "select_image", "toolbar=no,width=100,height=200");

		popup.form		= this.form;
		popup.layer		= layer;
		popup.callback	= this;

		popup.focus();
	}
}


		/*
		 * setDrawOrder
		 */

function LegendEdit_setDrawOrder(layer, new_value)
{
	var		sequence, enable, delelem, element;
	var		label, last_seq, elem, sub_name;
	var		old_value;


	if((sequence = elementByName(this.form, label = "sequence_" + layer)) == null)
	{
		itemNotDefined(label);
		return;
	}


	if(get_deleted(this.form, layer)=="true")
	{
		sequence.value = "";
		return;
	}


	old_value	= parseInt(this.getValue("sequence_" + layer));
	last_seq	= getMaxSequence(this.form);

	if(!(new_value <= 0) && !(new_value >= 0))		// Not a number
	{
		alert("Value '" + new_value + "' is invalid for layer '" + layer + "'");
		sequence.value = old_value;
		return;
	}

	new_value = parseInt(new_value);

	if(new_value < 1)				new_value = 1;
	else if(new_value > last_seq)	new_value = last_seq;

	/*
	 * Now we've got the 'old_value' and the 'new_value'
	 */

	//alert(old_value + " -> " + new_value);

	for(elem = 0; elem < this.form.elements.length; elem++)
	{
		element = this.form.elements[elem];

		if((element == sequence) || (element.name.substring(0, 9) != "sequence_"))
		{
			/*
			 * This element is not a sequence element or its the current layer
			 *   which will me manually updated at the end.
			 */
			continue;
		}

		sub_name	= element.name.substring(9, element.name.length);
		value		= parseInt(element.value);

		//alert(sub_name + " = " + value);

		if(new_value < old_value)
		{
			if((value >= new_value) && (value < old_value))
			{
				element.value = parseInt(value) + 1;
				this.setValue("sequence_" + sub_name, parseInt(value) + 1);
			}
		}
		else if(new_value > old_value)
		{
			if((value <= new_value) && (value > old_value))
			{
				element.value = parseInt(value) - 1;
				this.setValue("sequence_" + sub_name, parseInt(value) - 1);
			}
		}
	}

	this.setValue("sequence_" + layer, new_value);
	sequence.value = new_value;

	return;
}


		/*
		 * changeDrawOrder()
		 */

function LegendEdit_changeDrawOrder(layer, dir)
{
	var		sequence;

	if((sequence = elementByName(this.form, label = "sequence_" + layer)) == null)
	{
		itemNotDefined(label);
		return;
	}


	if(get_deleted(this.form, layer)=="true")
		return;

	if(dir == 'up')				new_value = parseInt(sequence.value) - 1;
	else if(dir == 'down')		new_value = parseInt(sequence.value) + 1;
	else if(dir == 'top')		new_value = 1;
	else if(dir == 'bottom')	new_value = getMaxSequence(this.form);

	this.setDrawOrder(layer, new_value);
}




function LegendEdit_enableDrawOrder(layer, checked)
{	var		sequence, label;

	if((sequence = elementByName(this.form, label = "sequence_" + layer)) == null)
		{
		itemNotDefined(label);
		return;
		}



	if (checked == null)

		{
		set_enabled(this.form,layer, get_enabled(this.form, layer));
		checked = get_enabled(this.form, layer);

//		alert("enabled is currently =  " + get_enabled(this.form, layer));	
//		alert("delete is currently =  " + get_deleted(this.form, layer));
//		alert("enabled is " + checked);
		}


	else if (checked == get_enabled(this.form,layer))

		
		{	
			return;
		}



	if((get_enabled(this.form, layer) == true) && (get_deleted(this.form, layer) == true))


		{

						/*
						 * This layer is enabled from delete mode. This means that no number
						 *   is assigned to the sequence ... so assign the lowest number now.
						 */


			set_deleted(this.form, layer, false);
			this.deleteDrawOrder(layer, false);

		}

	return;
}




function LegendEdit_deleteDrawOrder(layer, checked)
{
	var		sequence, label, elem, element;

//	alert("delete is set to " + get_deleted(this.form, layer)); 
//	alert("enabled is set to " + get_enabled(this.form, layer));
	
	if((sequence = elementByName(this.form, label = "sequence_" + layer)) == null)
	{
		itemNotDefined(label);
		return;
	}

	if(get_deleted(this.form, layer) == true)
	{
		/*
		 * This layer is being deleted ... need to remove the sequence number
		 */


		set_enabled(this.form, layer, false);

//		alert("enabled just set to "+ get_enabled(this.form, layer));

		for(elem = 0; elem < this.form.elements.length; elem++)
		{
			element = this.form.elements[elem];

			if((element != layer) && (element.name.substring(0, 9) == "sequence_"))
			{
				if(parseInt(element.value) > parseInt(sequence.value))
				{
					element.value = element.value - 1;
					this.setValue(element.name, element.value);
				}
			}
		}

		sequence.value = "";
	}
	else
	{
		/*
		 * This layer is being enabled ... need to assign a sequence number
		 */

		sequence.value = getMaxSequence(this.form) + 1;
	}


	set_deleted(this.form, layer, get_deleted(this.form,layer));


	this.setValue("sequence_" + layer, sequence.value);
	}

	
function LegendEdit_update()

	{
		var		keys, delim, string, order, layer, item, element, delcnt;
		var		enable, label;		

/*		 * Check if anything is being deleted		 */	
	for(delcnt = 0, item = 0; item < this.form.elements.length; item++)

		{		element = this.form.elements[item];		
	
		if((element.name.substring(0, 7) == "delete_") && element.checked)			
			delcnt++;
		}

	if(delcnt > 0)	
		{		if(!confirm("OK to delete " + delcnt + " layers"))		
		return(false);	
		}		

/*		 * Get the order of the layers		 */	


	keys = this.getKeys();	
	order = new Array();	


	for(item = 0; item < keys.length; item++)		
	
	{	string = keys[item];		
	


	if((delim = string.indexOf("sequence_")) != -1)		
		{	

			name	= string.substring(delim + 9, string.length);	
			value	= this.getValue(string);			
			order[value] = name;		
		}	
	}	

	
	for(layer = 0, item = 1; item < order.length; item++)	

		{		if((name = order[item]) != null)		
			{			this.layer[layer]	= name;			
						this.image[layer]	= this.hash.getValue("image_" + name);
			
	            if((enable = elementByName(this.form, "enable_" + name)) == null)				

			
				this.display[layer]	= true;			

				else this.display[layer] = enable.checked;            

	if((label = elementByName(this.form, "label_" + name)) != null)				
				this.label[layer]	= label.value;			
				else this.label[layer]	= "";			
				this.filter[layer]	= "";			
				layer++;
			}	
		}	


	this.layer.length = layer;	
	//return(false);		
	// Debugging
	
	return(true);
	
	}



function get_deleted(form,layer)
{

	var	 	delelem;
	
		delelem = elementByName(form, label="delete_"+layer);

		if ( delelem )
			return (getboolean(delelem));				
		else
			 return false;
}




function get_enabled(form,layer)

{

	var		enelem; 

		enelem = elementByName(form, label="enable_"+layer)	
				
		if ( enelem )
			return (getboolean(enelem));					
				
		else
			 return false;
}




function set_enabled(form ,layer, status)

{

	var		enelem; 

		enelem = elementByName(form, label="enable_"+layer)	;
	
		if ( enelem )
			setboolean( enelem, status);					
				
		else
			 return false;
}


function set_deleted(form,layer, status)

{

	var		delelem; 

		delelem = elementByName(form, label="delete_"+layer)	
					
		if ( delelem )
			setboolean(delelem, status);					
				
		else
			 return false;
}




function changeLayerImage(legend, layer)
{
	legend_edit.changeLayerImage(layer);
}

function changeDrawOrder(legend, layer, value)
{
	legend_edit.changeDrawOrder(layer, value);
}

function enableDrawOrder(legend, layer, enable)
{
	legend_edit.enableDrawOrder(layer, enable);
}


function getMaxSequence(form)
{
	var		elem, element, max_value;

	max_value = 0;

	for(elem = 0; elem < form.elements.length; elem++)
	{
		element = form.elements[elem];

		if(element.name.substring(0, 9) == "sequence_")
		{
			if(element.value > 0)
				max_value++;
		}
	}

	return(max_value);
}