// -------------------------------------------------------
// Biyn Development, LLC
// -------------------------------------------------------
// Copyright (c) 2006 all rights reserved
// -------------------------------------------------------
// greenleg.js
// -------------------------------------------------------
// utilizes prototype.js
// -------------------------------------------------------


// -------------------------------------------------------
// globals
// -------------------------------------------------------

// server destination
var postTo		 = '/ajax_request.php';
var ulDonePrefix = 'done_';

// data delimiter
var _dd		= "|";
var _dct	= "?";

// specific containters
var _selectors	= 'selectors';

// auto refresh
//var peLeads = null;
var peLeads = {
	pe:null,
	seconds: 0
};

// transport feedback 
var transportNotifier = {
	onCreate: function()
	{
		Element.show('spinId');
	},

	onComplete: function()
	{
		if(Ajax.activeRequestCount == 0)
		{
			Element.hide('spinId');
		}
	}
};

Ajax.Responders.register(transportNotifier);


// -------------------------------------------------------
// Help for IE
// -------------------------------------------------------
if(window.attachEvent)
{
	window.attachEvent("onload", initOnResize);
}

// when the size of the view_box div changes
// call onSelectorResize to resize the selector div
// in kind.
function initOnResize()
{
	objDiv = $('view_box');
	if(objDiv == null
	|| objDiv == 'undefined')
		return;
		
	objDiv.attachEvent('onresize', onSelectorResize);
}

function onSelectorResize()
{
	var objSel = $(_selectors);
	objSel.style.height = objSel.parentNode.offsetHeight;
}

// -------------------------------------------------------
// menus
// -------------------------------------------------------
function showSubmenu(menu_id)
{
	// define parameters
	var params = "object=menu&id=" + menu_id;
	executeHandlerPOST(params, handlerSubmenu);
}

function handlerSubmenu(reqObj)
{
	var responseText = getResponseText(reqObj);
	var arrayOut = responseText.split(_dd);
	
	resetMenuCss();
	
	var li = $("mi_" + arrayOut[0]);
	li.className = "current";
	
	var ss = $('secondary')
	ss.innerHTML = arrayOut[1];
	
	var l = arrayOut.length;
	if(l > 2)
	{
		for(i=2; i<l; ++i)
		{
			eval(arrayOut[i]);
		}
	}
}

function resetMenuCss()
{
	var main = $('mainmenu');
	var items = $A($T(main, 'li'));
	items.each(function(li){li.className = "";});
}

// -------------------------------------------------------
// selectors
// -------------------------------------------------------
function showSelectors(menu_id)
{
	// define parameters
	var params = "object=" + _selectors + "&id=" + menu_id;
	executeHandlerPOST(params, handlerSelectors);
}

function handlerSelectors(reqObj)
{
	var sels = $(_selectors);

	var responseText = getResponseText(reqObj);
	var arrayOut = responseText.split(_dd);
	
	sels.innerHTML = arrayOut[0];
	
	var l = arrayOut.length;
	if(l > 1)
	{
		for(i=1; i<l; ++i)
		{
			eval(arrayOut[i]);
		}
	}

	// do rounding
	roundElements(sels);
}

// -------------------------------------------------------
// Ajax form submission
// -------------------------------------------------------
function isFile(e)
{
	return (e.type == "file");
}

function createflagElementId(iFrameId)
{
	return ulDonePrefix + iFrameId;
}

function enterKey(event, id)
{
	if(event.keyCode != 13)
		return true;

	var o = $(id);
	
	if(o == null || o == 'undefined')
		return true;
		
	o.click();
	
	event.cancelBubble = true;
	if(event.stopPropigation) event.stopPropigation();
	return false;
}

function ajaxEnterKey(event, id)
{
	if(event.keyCode != 13)
		return true;

	var o = $(id);
	
	if(o == null || o == 'undefined')
		return true;
		
	o.click();

	return false;
}

function ajaxAddUploadCmd(form, submitter)
{
	var h	= document.createElement("input");
	h.type	= "hidden";
	h.name	= submitter.name;
	h.value	= submitter.value;

	form.appendChild(h);
}

function ajaxForm(id, submitter, confirm_message, extraParams)
{
	var form  = $(id);
	submitter = $(submitter);
	
	var out = "";
	var elements = $A(form.elements);

	// any upload fields required? 
	// Note: if psudoform, "form.elements" will not exist but will work in "else" case.
	if(form.elements
	&& elements.any(function(e){ return isFile(e)}))
	{
		var iframeNameId = id + '_iframe';
		
		// set form's action
		form.action = postTo;

		// set form's target as the iframe
		form.target = iframeNameId;

		var flagElementId = createflagElementId(iframeNameId);

		// if first time through
		if($(iframeNameId) == null)
		{
			var iframeHTML = '<iframe class="uploader" name="' + iframeNameId + '" ' + 'id="' + iframeNameId + '" src="about:blank"></iframe>'
		
			// create hidden iframe to upload
			new Insertion.After(id, iframeHTML);

			// create hidden element to contain done flag
			new Insertion.After(iframeNameId, '<span class="uploader" id="' + flagElementId + '" />');
			
			// set event on the iframe
			Event.observe(iframeNameId, 'load', onUploadDone, false);
		}
		
		var spinner = $("spinId");
		if(spinner) spinner.style.display = '';

		var hint = { flagId: flagElementId, iframeId: iframeNameId, done: false };
		new PeriodicalExecuter(doUploadUpdate, 1, hint);
		
		if(submitter != undefined
		&& submitter != null)
		{
			// add hidden field w/ n/v == submitter's n/v
			ajaxAddUploadCmd(form, submitter);
		}
		
		form.submit();
	}
	else
	{
		if(submitter != undefined
		&& submitter != null)
		{
			submitter.submitter = true;
		}

		if(confirm_message != undefined
		&& confirm_message != null
		&& confirm_message != '')
		{
			if(!confirm(confirm_message))
			{
				if(submitter != undefined
				&& submitter != null)
				{
					submitter.submitter = false;
				}

				return;
			}
		}
		
		var params = Form.serialize(form);
		
		if(extraParams != undefined
		&& extraParams != null
		&& extraParams != '')
		{
			params += '&' + extraParams;
		}
		
		executePOST(params);
	}
}

function doUploadUpdate(pe)
{
	if(pe.hint.done == true)
	{
		pe.stop();
		
		var iframe = $(pe.hint.iframeId);
		var doc = ((iframe.contentDocument) ? iframe.contentDocument : iframe.ownerDocument.frames[0].document);
		var content = doc.body.innerHTML;
		iframe = null;

		var spinner = $("spinId");
		if(spinner) spinner.style.display = 'none';

		updateGeneric(getResponseText(content));
	}

	var flag = $(pe.hint.flagId);
	if(flag == null)
	{
		pe.stop();	
		return;	
	}
	
	if(flag.innerHTML == (true).toString())
	{
		pe.hint.done = true;
	}
}

function onUploadDone()
{
	var doc = ((this.contentDocument) ? this.contentDocument : this.document);
	var body = ($T(doc, 'body'))[0];
	if(body == null)
		return;
	
	if(body.innerHTML == '')
		return;

	var flag = $(createflagElementId(((this.id) ? this.id : this.frames[0].name)));
	flag.innerHTML = (true).toString();
}

// -------------------------------------------------------
// generic POST
// -------------------------------------------------------
function executePOST(params, async)
{
	if(async == undefined
	|| async == null)
	{
		async = true;
	}

	executeHandlerPOST(params, handlerGeneric, async);
}

function handlerGeneric(reqObj)
{
	if(reqObj.readyState == 4)
	{
		updateGeneric(getResponseText(reqObj));
	}
}

function buildSelector(o, aResults)
{
	var selector	= o.className;
	var selectorOp	= ".";
	var tag			= o.tagName.toLowerCase();
	
	if(selector != '')
	{
		aResults[aResults.length] = selector;
		aResults[aResults.length] = tag + selectorOp + selector;
	}
	
	selector	= o.id;
	selectorOp	= "#";
	
	if(selector != '')
	{
		aResults[aResults.length] = selector;
		aResults[aResults.length] = tag + selectorOp + selector;
	}
}

function buildSelectors(o, aResults)
{
	if(o.style.display == 'none')
		return aResults;
	
	buildSelector(o, aResults)
	for(var i = 0; i < o.childNodes.length; ++i)
	{
		var child = o.childNodes[i];
		if(child.nodeType == 3
		|| child.style.display == 'none')
			continue;

		buildSelectors(child, aResults);
	}
	
	return aResults;
}

function applyRound(o, count)
{
	if(RMap.container == null
	|| RMap.selectors.length < 1)
		return;
	
	var aCandidates = o.selector.split(" ");
	var candidate = aCandidates[0];
	
	for(var i = 0; i < RMap.selectors.length; ++i)
	{
		if(candidate == RMap.selectors[i])
		{
			Rounder.round(o);
		}
	}
}

function roundElements(container)
{
	if(RMap != null
	&& RMap != 'undefined')
	{
		RMap.container = container;
		RMap.selectors = [];
		buildSelectors(RMap.container, RMap.selectors);
		RMap.round(applyRound);
	}
}

function updateGeneric(outText)
{
	// djs : added divide() to prototype library.
	var o = outText.divide(_dd);
	
	var container = $(o.left);
	if(container == null)
	{
		alert("no container");
		Element.hide('spinId');
	}

	var clean = o.right.stripScripts();
	
	var scripts = o.right.extractScripts();
	
	var arrayOut = clean.split(_dd);
	
	container.innerHTML = arrayOut[0];

	if(scripts.length > 0)
	{ 
		var z = 0;
		while(z < scripts.length)
		{
			var script = scripts[z++];
			eval(script); 
		}
	}
	
	var l = arrayOut.length;
	if(l > 1)
	{
		for(y=1; y<l; ++y)
		{
			var command = arrayOut[y];
			while(command.indexOf('&amp;') != -1)
			{
				command = command.replace('&amp;', '&');
			}
			eval(command);
		}
	}

	// do rounding
	roundElements(container);
	
	// IE hover
	if( document.updateBehavior != null 
	&&  document.updateBehavior != 'undefined' 
	&& (typeof document.updateBehavior == 'function'))
	{
		document.updateBehavior();
	}
}

function handlerGenericEx()
{
	if(reqObjX.readyState == 4)
	{
		var responseText = reqObjX.responseText;
		var arrayOut = responseText.split(_dd);
		
		var container = $(arrayOut[0]);
		if(container == null) alert("no container");
		
		container.innerHTML = arrayOut[1];
	}
}

// -------------------------------------------------------
// ajax support
// -------------------------------------------------------
// using prototype library
function executeHandlerPOST(params, handler, async)
{
	if(async == undefined
	|| async == null)
	{
		async = true;
	}
	
	if(async)
	{
		new Ajax.Request(postTo, { method: 'post', parameters: params, onComplete: handler});
	}
	else // synchronous
	{
		var req = new Ajax.Request(postTo, { method: 'post', parameters: params, asynchronous: false});
		updateGeneric(getResponseText(req.transport));
		Element.hide('spinId');
	}
}

// gets and validates results
function getResponseText(obj)
{
	var text = "";
	
	// upload
	if(typeof obj == 'string')
		text = obj;
	else
		text = obj.responseText;

	checkResponse(text);

	return text;
}

// validates return string
function checkResponse(responseText)
{
	if(responseText.indexOf(_dct) == 0)
	{
		var directive = responseText;
		var index = directive.indexOf(_dd);
		if(index != -1)
			directive = directive.slice(0, index);

		directive = directive.substring(1);
		window.top.location=directive;
		
		// bust out -- redirecting
		throw null;
	}
}

// -------------------------------------------------------
// general functions
// -------------------------------------------------------
function $T(object, tag)
{
	return object.getElementsByTagName(tag);
}