// ajax.js

function httpSubmitForm(form, url, function_name)
{
	var req;
	var date = new Date();
	var timestamp = date.getTime();
	
	url = url + (url.indexOf('?') == -1 ? '?' : '&') + 'timestamp=' + timestamp

	var fields = getFormFields(form)
	var input = '';

	var i;
	foreach(fields, function(field)
	{
	    var name = field.name;
	    var value = getFieldValue(field);
  		input += urlencode(name) + '=' + urlencode(value) + '&';
    });

	input = rtrim(input, '&');

	try
	{
		req = new ActiveXObject('Msxml2.XMLHTTP');
	}
	catch(e)
	{
		try
		{
			req = new ActiveXObject('Microsoft.XMLHTTP');
		}
		catch(e)
		{
			try
			{
				req = new XMLHttpRequest();
			}
			catch(e)
			{
				throw 'Could not create XMLHttp Object';
			}
		}
	}

	try
	{
		req.open('POST', url, true);
	}
	catch(e)
	{
		throw 'Request failed - ' + e;
	}

	req.onreadystatechange = function() 
	{
		try
		{
			if(req.readyState == 4)
			{
				if(req.status != 200)
					throw req.status;

				if(!empty(function_name))
				{
					var response = req.responseText;
					eval(function_name + '(form, response);');
				}
			}
		}
		catch(e)
		{
			//added conditional to avoid onunload event trigger alert. Not sure how else to fix this
			if(typeof(e) == 'number')
				alert("httpSubmitForm() error:\n\nResponse failed - " + e);
		}
	};

	try
	{
		req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
		req.setRequestHeader('Content-Length', input.length);
		req.setRequestHeader('Connection', 'close');
		req.send(input);
	}
	catch(e)
	{
		throw 'Request send failed - ' + e;
	}
}

function httpRequest(input, url, function_name)
{
	var req;
	var date = new Date();
	var timestamp = date.getTime();
	
	if(url.indexOf('?') == -1)
		url = url + '?timestamp=' + timestamp
	else
	{
		var split_url = url.split('?');
		url = url + '&timestamp=' + timestamp;
	}

	try
	{
		req = new ActiveXObject('Msxml2.XMLHTTP');
	}
	catch(e)
	{
		try
		{
			req = new ActiveXObject('Microsoft.XMLHTTP');
		}
		catch(e)
		{
			try
			{
				req = new XMLHttpRequest();
			}
			catch(e)
			{
				throw 'Could not create XMLHttp Object';
			}
		}
	}

	try
	{
		req.open('POST', url, true);
	}
	catch(e)
	{
		throw 'Request failed - ' + e;
	}

	req.onreadystatechange = function() 
	{
		try
		{
			if(req.readyState == 4)
			{
				if(req.status != 200)
					throw req.status;
	
				if(!empty(function_name))
				{
					var response = req.responseText;
					eval(function_name + '(response);');
				}
			}
		}
  	catch(e)
		{
			//added conditional to avoid onunload event trigger alert. Not sure how else to fix this
			if(typeof(e) == 'number')
  			alert("httpRequest() error:\n\nResponse failed - " + e);
  	}
	};

	try
	{
		req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
		req.setRequestHeader('Content-Length', input.length);
		req.setRequestHeader('Connection', 'close');
		req.send(input);
	}
	catch(e)
	{
		throw 'Request send failed - ' + e;
	}
}

function processInputErrors(form, input_errors)
{
	if(form = $(form))
	{
	  	var i;

		//Clear old errors and create target_client array from field data
	  	var fields = getFormFields(form);
	  	foreach(fields, function(field)
	  	{
	  		field.className = field.className.replace(/\_{0,1}error/, '');

	  		var error_span;
	  		if(error_span = getNextSibling(field, 'SPAN'))
	  			removeChildNodes(error_span);
	  	});

		// If input errors, display error messages
	  	if(!empty(input_errors))
	  	{
	  		var set_focus = false;

	  		foreach(input_errors, function(input_error, key)
	  		{
				if(input_error)
				{
		  			var field_name = key;
		  
		  			if(field = eval('form.' + field_name))
		  			{
		  				if(!set_focus)
		  				{
		  					field.focus();
		  					
		  					if(field.type == 'text' || field.type == 'textarea')
			  					field.select();
		  					set_focus = true;
		  				}
		  					
		  				field.className = (empty(field.className)) ? 'error' : field.className + '_error';
		
		  				var error_span;
		  				if(error_span = getNextSibling(field, 'SPAN'))
		  				{
		  					error_span.innerHTML = error_span.innerHTML + input_error + '<br />';
		  					error_span.style.display = 'block';
		  				}
		  			}
		  		}
	  		});

	  		return false;
	  	}

	  	return true;
	}
}

function parseXMLNode(xml_doc, node_name)
{
	try
	{
		if(typeof(xml_doc) == 'undefined' || typeof(node_name) == 'undefined')
			throw invalidFunctionCall(arguments, 'xml_doc', 'node_name');

	  	// Get returned target
	  	var target_node = xml_doc.getElementsByTagName(node_name).item(0);
	  	var target = new Array();
	  	target['id'] = target_node.attributes.getNamedItem('id').value;
	
		var i;
	  	for(i=0; i<target_node.childNodes.length; i++)
	  		if((name = target_node.childNodes[i].nodeName) != '#text')
	  			target[name] = (target_node.childNodes[i].firstChild) ? target_node.childNodes[i].firstChild.nodeValue : '';
	  	
	  	return target;
	}
	catch(e)
	{
		alert("parseXMLNode() error:\n\n" + e + "\n\nStack:\n" + (typeof(e.stack) != 'undefined' ? e.stack.replace(/\n/g, "\n\n") : ''));
		return false;
	}
}

function ajaxUsernameAvailable(username_available)
{
    username_available = (username_available == 1); //fix for js suckiness
    var status;
    var status_message;

    if(username_available)
    {
        status = 'success';
        status_message = 'Available';
    }
    else
    {
        status = 'error';
        status_message = 'Not Available';
    }
        
    replaceSpan('username_available_span', '<span class=\"silk_' + status + '\">' + status_message + '</span>');
}

// array.js

function foreach(object, block, context) 
{
	for (var key in object)
	{
		if(typeof object[key] == 'function')
			continue;
		block.call(context, object[key], key, object);
	}
}

function array_key_exists(search_key, array)
{
	var exists = false;
	foreach(array, function(value, key) 
	{	
		if(key == search_key) 
		{
			exists = true; 
			return;
		}
	});

	return exists;
}

function in_array(array, search_value)
{
	var in_array = false;
	foreach(array, function(value, key) 
	{	
		if(value == search_value)	
		{
			in_array = true; 
			return;
		}
	});

	return in_array;
}

function insertElementAt(array, element, index)
{
	var i=count(array);

	for(i; i>index; i--) 
		array[i] = array[i-1];
	
	array[i] = element;
}

function insertElementIntoSorted(array, insert_value, insert_key)
{
	var insert_key = insert_key || '';
	var temp_array = new Array();

	var inserted = false;
	var key;
	foreach(array, function(value, key)
	{
		if((typeof insert_value == 'string' && insert_value.toLowerCase() < value.toLowerCase()) || insert_value < value)
		{
			inserted = true;
			
			if(!empty(insert_key))
				temp_array[insert_key] = insert_value;
			else
				temp_array.push(insert_value);
		}
			
		if(empty(insert_key))
		{
			if(inserted)
				temp_array.push(array[key + 1]);
			else
				temp_array.push(value);
		}
		else
			temp_array[key] = value;
	});

	if(!inserted)
	{
		if(!empty(insert_key))
			temp_array[insert_key] = insert_value;
		else
			temp_array.push(insert_value);
	}

	clone(array, temp_array);
}

function clone(array_clone, array)
//cloning in js is pretty horrible. I had to keep the original array_clone, remove all elements, then add all array elements
{
	var key;
	for(key in array_clone)
		delete array_clone[key];
	
	for(key in array)
		array_clone[key] = array[key];
}

function removeValue(array, search_value)
{
	var key;
	var removed_keys = new Array();
	foreach(array, function(value, key)
	{
		if(value == search_value)
		{
			removed_keys.push(key);
			delete array[key];
		}
	});
	
	return removed_keys;
}

function removeNull(array) 
{
	foreach(array, function(value, key) 
	{
		if(isEmpty(value)) 
			delete array[key];
	});
}

function moveValueToBeginning(array, search_value)
{
	removed_keys = removeValue(array, search_value);

	var temp_array = new Array();
	foreach(removed_keys, function(value)
	{
		temp_array[value] = search_value;
	});

	foreach(array, function(value, key)
	{
		temp_array[key] = value;
	});	

	clone(array, temp_array);
}

function moveValueToEnd(array, search_value)
{
	removed_keys = removeValue(array, search_value);
	var temp_array = new Array();
	
	foreach(array, function(value, key)
	{
		temp_array[key] = value;
	});	
		
	foreach(removed_keys, function(value)
	{
		temp_array[value] = search_value;
	});
	
	clone(array, temp_array)
}

// calendar.js

function getTextMonth(month)
{
    switch(month)
    {
        case '01' : return 'January'; break;
        case '02' : return 'February'; break;
        case '03' : return 'March'; break;
        case '04' : return 'April'; break;
        case '05' : return 'May'; break;
        case '06' : return 'June'; break;
        case '07' : return 'July'; break;
        case '08' : return 'August'; break;
        case '09' : return 'September'; break;
        case '10' : return 'October'; break;
        case '11' : return 'November'; break;
        case '12' : return 'December'; break;
    }
}

function getNumDaysInMonth(month, year) 
{
	month = Number(month);
	year = Number(year);
	
	switch(month) 
	{
		case 1: num_days = 31; break;
		case 2: if(year % 4 == 0) {num_days = 29;} else {num_days = 28;} break;
		case 3: num_days = 31; break;
		case 4: num_days = 30; break;
		case 5: num_days = 31; break;
		case 6: num_days = 30; break;
		case 7: num_days = 31; break;
		case 8: num_days = 31; break;
		case 9: num_days = 30; break;
		case 10: num_days = 31; break;
		case 11: num_days = 30; break;
		case 12: num_days = 31; break;
		default : throw 'invalid month number ' + month + ' entered';
	}

	return num_days;
}

function getPrevMonth(month) { return (month > 1) ? month - 1 : 12; }
function getNextMonth(month) { return (month < 12) ? month + 1 : 1; }

function updateNumDays(field)
{
	if(field = getElement(field))
	{
		var field_id = field.getAttribute('id');
		var year = document.getElementById(field_id + '_year');
		var month = document.getElementById(field_id + '_month');
		var day = document.getElementById(field_id + '_day');

		var old_num_days = day.options.length - 1; //-1 for 'Day' as first option
		
		var date =new Date();
		var month_value = (month.value != 0) ? month.value : str_pad(date.getMonth() + 1, 2, 0, 'STR_PAD_LEFT');
		var year_value = (year.value != 0) ? year.value : date.getFullYear();
		var new_num_days =  getNumDaysInMonth(month_value, year_value);
		
		var difference = new_num_days - old_num_days;

		var i;
		if(difference < 0)
		{
			for(i=0; i<(-difference); i++)
				day.removeChild(day.options[day.options.length-1]);
		}
		else if(difference > 0)
		{
			for(i=old_num_days + 1; i<=new_num_days; i++)
			{
				var option = document.createElement('OPTION');
				option.value = i;
				var option_text = document.createTextNode(i);
				option.appendChild(option_text);
				day.appendChild(option);
			}
		}
	}
}

// check_format.js

function checkEmailFormat(email) 
{
	if(!email.match(/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/i))
		return 'Invalid email address.';
	return false;
}

function checkPhoneNumberFormat(phone_number) 
{
	phone_number = phone_number.replace(/[^0-9]/g, '');
	if(phone_number.length != 10)
		return 'Phone Number must contain exactly 10 digits.';
	return false;
}

function checkZipFormat(zip) 
{
	if(!zip.match(/^[0-9]{5}$/))
		return 'Zip Code must contain exactly 5 digits.';
	return false;
}

// dom.js

function getElement(element) { return $(element); }

function getRelatedNode(relation, element, tag)
{
    if(element = $(element))
    {
        if(typeof(tag) == 'undefined')
            tag = '*';

        while(eval('element.'+relation))
        {
            element = eval('element.'+relation);
            if(tag == '*' || tag == element.nodeName)
                return element;
        }
    }
    
    return false;    
}

function getNextSibling(element, tag) { return getRelatedNode('nextSibling', element, tag); }
function getPrevSibling(element, tag) { return getRelatedNode('previousSibling', element, tag); }
function getParentNode(element, tag) { return getRelatedNode('parentNode', element, tag); }

function getElementsByTagName(tag, node, levels_deep)
{
    var node = node || document.getElementsByTagName('body').item(0);
    var tag = tag || '*';

    if(node = $(node))
    {
        //built-in js function adds index length, which I can't figure out how to get rid of
//        if(typeof(levels_deep) == 'undefined' || levels_deep == -1) 
//            return node.getElementsByTagName(tag);

        var elements = new Array();

        if(typeof(levels_deep) == 'undefined')
            levels_deep = -1;
        else if(levels_deep == 0)
            return elements;

        if(node.firstChild)
        {
            foreach(node.childNodes, function(child_node)
            {
                if(tag == '*' || child_node.nodeName == tag)
                    elements.push(child_node);    
        
                // If searching the next level down and element has children, 
                // recall this function for the element with one search level less
                // Then merge the returned elements array and the current elements array

                if((levels_deep == -1 || Number(levels_deep) > 0) && child_node.firstChild)
                {
                    var child_elements = getElementsByTagName(tag, child_node, (levels_deep == -1 ? levels_deep : (levels_deep - 1)));
        
                    if(typeof(child_elements) == 'object')
                        elements = elements.concat(child_elements);
                }
            });
        }

        // return the elements array
        return elements;
    }
}

function getElementsByClass(search_class, node, tag, levels_deep)
{
    var node = node || document.getElementsByTagName('body').item(0);
    
    if(node = $(node))
    {
        if(typeof(tag) == 'undefined')
              tag = '*';

        var elements = new Array();
        var temp_elements = new Array();

        if(typeof(levels_deep) == 'undefined')
        {
            temp_elements = document.getElementsByClassName(search_class, node);
            if(tag == '*')
            {
                elements = temp_elements;
            }
            else
            {        
                foreach(temp_elements, function(element)
                {
                    if(element && element.nodeName && element.nodeName.indexOf(tag) != -1) 
                        elements.push(element);
                });
            }
        }
        else
        {
            temp_elements = getElementsByTagName(tag, node, levels_deep);
            if(tag == '*')
            {
                elements = temp_elements;
            }
            else
            {        
                foreach(temp_elements, function(element)
                {
                    if(element && element.className && element.className.indexOf(search_class) != -1) 
                        elements.push(element);
                });
            }
        }
                  
        return elements;
    }
}

function getStyle(element, property)
{
	if(!(element = $(element)))
	    return false;

	if (element.currentStyle)
    	return element.currentStyle[property];
	
	if (window.getComputedStyle)
		return document.defaultView.getComputedStyle(element, null).getPropertyValue(property);
		
	return false;
}

function removeChildNodes(element)
{
    if(element = $(element))
        while(element.firstChild)
            element.removeChild(element.firstChild);
}

//This has to be prefaced with "my" since IE has a non-DOM method object.removeNode
function myRemoveNode(element)
{
    if(element = $(element))
    {
        removeChildNodes(element);
        element.parentNode.removeChild(element);
    }
}

function insertBefore(insert_element, element)
{
    if((insert_element = $(insert_element)) && (element = $(element)))
        element.parentNode.insertBefore(insert_element, element);
}

function insertAfter(insert_element, element)
{
    if((insert_element = $(insert_element)) && (element = $(element)))
    {
        if(element.nextSibling)
            element.parentNode.insertBefore(insert_element, element.nextSibling);
        else
            element.parentNode.appendChild(insert_element);
    }
}

function showElement(element) { if(element = $(element)) element.style.display = ''; }
function hideElement(element) { if(element = $(element)) element.style.display = 'none'; }
function toggleElement(element, node) { if(element = $(element)) element.style.display = (element.style.display == 'none') ? '' : 'none'; }

function showElements(class_name, node, tag)
{
    var node = node || document;
    if($(node))
    {
        if(typeof(tag) == 'undefined')
              tag = '*';

        var elements = getElementsByClass(class_name, node, tag);
            
        var i;
        foreach(elements, function(element)
        {
            element.style.display = '';
        });
    }
}

function hideElements(class_name, node, tag)
{
    var node = node || document;
    if($(node))
    {
        if(typeof(tag) == 'undefined')
              tag = '*';
        var elements = getElementsByClass(class_name, node, tag);

        foreach(elements, function(element) 
        {
            element.style.display = 'none';
        });
    }
}

function toggleElements(class_name, node, tag, levels_deep)
{
    var node = node || document;
    if($(node))
    {
        if(typeof(tag) == 'undefined')
              tag = '*';
        var elements = getElementsByClass(class_name, node, tag);

        foreach(elements, function(element)
        {
            element.style.display = (element.style.display == 'none') ? '' : 'none';
        });
    }
}

function toggleCheckboxElement(checkbox_element, element) { if(element = $(element)) element.style.display = (checkbox_element.checked ? '' : 'none'); }

function replaceSpan(span, value, default_value) { if(span = $(span)) span.innerHTML = (empty(value) && typeof(default_value) != 'undefined') ? default_value : value; }

function replaceSpans(span_class, value, default_value)
{
    if(empty(value) && typeof(default_value) != 'undefined')
        value = default_value;

    var spans = getElementsByClass(span_class);
    foreach(spans, function(span)
    {
        span.innerHTML = value;
    });
}

function swapSpans(span_1, span_2)
{
    if(span_1 = $(span_1))
    {
        if(span_2 = $(span_2))
        {
            var temp_innerHTML = span_2.innerHTML;
            replaceSpan(span_2, span_1.innerHTML);
            replaceSpan(span_1, temp_innerHTML);
        }
    }
}

function setFocus(element) { if(element = $(element)) element.focus(); }

function addEventHandler(element, event, function_name, use_capture)
{   
    if(!(element = $(element)))
        return;
        
    if (typeof(use_capture) == 'undefined')
        use_capture = false;

    var event = event.replace(/^on/, '');
    var onevent = 'on' + event;

    if (element.addEventListener)     //DOM
    {
        element.addEventListener(event, function_name, use_capture);
    }
    else if (element.attachEvent) //IE 
    {
        element.attachEvent(onevent, function_name);
    }
    else if (document.getElementById) //older browsers
    {
        element.onevent = function_name;
    }
}

function addEventHandlers(class_name, event, function_name)
{
    var elements = getElementsByClass(class_name);
    if (elements)
    {
        foreach (elements, function(element)
        {
            addEventHandler(element, event, function_name);
        });
    }
}

function Window(url, name, width, height)
{
    this.url = url;
    this.name = name;
    this.width = width;
    this.height = height;
    this.top = this.left = 0;
    this.is_centered = this.toolbar = this.menubar = this.location = this.directories = this.resizable = this.scrollbars = this.statusbar = false;
}

Window.prototype.url;
Window.prototype.name;
Window.prototype.width;
Window.prototype.height;
Window.prototype.is_centered;
Window.prototype.top;
Window.prototype.left;
Window.prototype.toolbar;
Window.prototype.menubar;
Window.prototype.location;
Window.prototype.directories;
Window.prototype.resizable;
Window.prototype.scrollbars;
Window.prototype.statusbar;

Window.prototype.open = function()
{
    if (this.is_centered)
    {
        this.top = (screen.height / 2) - (this.height / 2);
        this.left = (screen.width / 2) - (this.width / 2);
    }
    
    var my_window = window.open(this.url, this.name,
        'top='+this.top
        +',left='+this.left
        +',width='+this.width
        +',height='+this.height
        +',toolbar='+Number(this.toolbar)
        +',menubar='+Number(this.menubar)
        +',location='+Number(this.location)
        +',directories='+Number(this.directories)
        +',resizable='+Number(this.resizable)
        +',scrollbars='+Number(this.scrollbars)
        +',statusbar='+Number(this.statusbar));
 
    my_window.focus();
}

function centeredPopup(url, window_name, width, height)
{
    var popup = new Window(url, window_name, width, height);
    popup.is_centered = true;
    popup.scrollbars = true;
    popup.open();   
}

function insertLiIntoSortedUl(li, parent_ul, sort_name)
// inserts an li into a ul and sorts based upon its name attribute
{
    if(!(li = $(li)))
        return false;

    li.setAttribute('name', sort_name);
    var parent_lis = getElementsByTagName('LI', parent_ul, 1);

    if(count(parent_lis) == 0)
        parent_ul.appendChild(li);
    else
    {
        //Used for sorting purposes only
        sort_name = sort_name.toLowerCase();

        var i;
        for(i=0; i< parent_lis.length; i++)
        {
            var li_name = parent_lis[i].getAttribute('name').toLowerCase();

            if(li_name == sort_name)
            {
                insertAfter(li, parent_lis[i]);
                break;
            }
            else
            {
                var j=0;

                while(sort_name.charAt(j) == li_name.charAt(j))
                    j++;

                if(sort_name.charAt(j) > li_name.charAt(j))
                {
                    if(i < parent_lis.length - 1)
                        continue;
                    else
                    {
                        insertAfter(li, parent_lis[i]);
                        break;
                    }
                }
                else
                {
                    insertBefore(li, parent_lis[i]);
                    break;
                }
            }
        }
    }
}


function togglePlusMinus(img, path)
{
    var path = path || 'http://www.personalmaestro.com/shared_includes/images/icons/';

    if(img = $(img))
        if(img.nodeName == 'IMG')
            img.src = (img.src.substr(-8) == 'plus.gif') ? path + 'minus.gif' : path + 'plus.gif';
}


// form.js

function getFormFields(form)
{	
	if(!(form = $(form)))
		return false;

	var input_fields = getElementsByTagName('INPUT', form);
	var select_fields = getElementsByTagName('SELECT', form);
	var textarea_fields = getElementsByTagName('TEXTAREA', form);

	fields = input_fields.concat(select_fields, textarea_fields);
	return fields;
}

function getFormValue(field)
{
	if(!(field = $(field)))
		return false;

	var type = field.type;
	if(type == 'text' || type == 'textarea' || type == 'hidden' || type == 'submit' || type == 'file' || type == 'button' || type == 'password')
		return field.value;
	else if(type == 'select-one')
		return field.options[field.selectedIndex].value;
	else if(type == 'radio') 
	{
		if(field.checked)
			return field.value;
		else 
		{
			var field_name = field.attributes.getNamedItem('name').value;
			
			var i=1;
			while(field = $(field_name + i)) 
			{
				if(field.checked)
					return field.value;
				else
					i++;
			}
		}
	}
	else if(type == 'checkbox') 
		return (field.checked) ? 1 : 0;
}

function getOptionText(field, value)
{
	if(!(field = $(field)))
		return false;

	if(empty(value))
		return field.options[field.selectedIndex].innerHTML;

	var i;
	for(i in field.options)
		if(field.options[i].value == value)
			return field.options[i].innerHTML;
}

function replaceOptionText(field, value, text)
{
	field = $(field);
	var i;
	for(i in field.options)
	{
		if(field.options[i] && field.options[i].value == value)
		{
			field.options[i].innerHTML = text;
			break;
		}
	}
}

function getSelectedOptionText(field)
{
	if(!(field = $(field)))
		return false;

	var i;
	for(i in field.options)
		if(field.options[i].selected)
			return field.options[i].innerHTML;
}

function disableFormField(field) { if(field = $(field)) field.disabled = true; }
function disableFormFields(class_name) 
{
	var i;
	if(fields = getElementsByClass(class_name))
		for(i in fields)
			fields[i].disabled = true;
}

function enableFormField(field) { if(field = $(field)) field.disabled = false; }
function enableFormFields(class_name)
{
	var i;
	if(fields = getElementsByClass(class_name))
		for(i in fields)
			fields[i].disabled = false;
}

function setFormValue(field, value)
{
	if(!(field = $(field)))
		return false;

	var type = field.type;
	
	if(type == 'radio') 
	{
		if(field.value == value)
			field.checked = true;
		else 
		{
			var i=1;
			while(field = $(field + i)) 
			{
				if(field.value == value) 
				{
					field.checked = true;
					break;
				}
				else
					i++;
			}
		}
	}
	else if(type == 'checkbox') 
	{
		value = (value == 'on' || value == 1) ? true : false;
		field.checked = value;
	}
	else
    	field.value = value
}

function setFormValues(class_name, value)
{
	var elements = getElementsByClass(class_name);
	var i;
	for(i in elements)
		setFormValue(elements[i], value);
}

function maxLength(textarea, length)
{
	if(!(textarea = $(textarea)))
		return false;
		
	var length_span = $(textarea.id + '_length');
	if(textarea.value.length > length)
	{
		textarea.className = 'error';
		if(length_span)
		{
			length_span.className = 'error';
			length_span.style.fontWeight = 'bold';
		}
	}
	else
	{
		textarea.className = '';
		if(length_span)
		{
			length_span.className = '';
			length_span.style.fontWeight = '';
		}
	}
	
	if(length_span)
		replaceSpan(length_span, textarea.value.length);
}

//would like to decommission these but they are being used by emaestropro/client_user/manage_client_users.php
function createField(type, id, name, label, value, input_attributes, options, html_after_input_field)
{
	var innerHTML = ''
+'		<z:field>'
+'			<label for="' + id + '"' + (type == 'submit' ? 'onclick="return false;"' : '') + '>' + (!empty(label) ? label : '&nbsp;') + '</label>';
	
	switch(type.toLowerCase())
	{
		case 'text'		: innerHTML += ''
+'			<input id="' + id + '" type="text" name="' + name + '" value="' + (typeof(value) != 'undefined' ? value : '') + '" ' + (typeof(input_attributes) != 'undefined' ? input_attributes : '') + ' />'; break;
		case 'textarea'	: innerHTML += ''
+'			<textarea id="' + id + '" name="' + name + '" ' + (typeof(input_attributes) != 'undefined' ? input_attributes : '') + '>' + (typeof(value) != 'undefined' ? value : '') + '</textarea>'; break;
		case 'select'	: innerHTML += ''
+'			<select id="' + id + '" name="' + name + '" ' + (typeof(input_attributes) != 'undefined' ? input_attributes : '') + '>' + (typeof(value) != 'undefined' ? createSelectOptions(options, value) : createSelectOptions(options))
+'			</select>'; break;
		case 'checkbox'	: innerHTML += ''
+'			<input id="' + id + '" type="checkbox" name="' + name + '" ' + ((typeof(value) != 'undefined' && value) ? 'CHECKED' : '') + ' class="checkbox" ' + (typeof(input_attributes) != 'undefined' ? input_attributes : '') + ' />'; break;
		case 'submit'	: innerHTML += ''
+'			<input id="' + id + '" type="submit" name="' + name + '" value="' + value + '" class="button" ' + (typeof(input_attributes) != 'undefined' ? input_attributes : '') + ' />'; break;
	}
	
	if(typeof(html_after_input_field) != 'undefined')
		innerHTML += html_after_input_field;

	innerHTML += ''
+'			<span class="error_span"></span>'
+'		</z:field>';

	return innerHTML;
}

function createPhoneNumberField(id, name, label, value, html_after_input_field)
{
	if(typeof(value) == 'undefined')
		var value = '';
		
	if(typeof(html_after_input_field) == 'undefined')
		var html_after_input_field = '';
		
	return createField('text', id, name, label, value, 'maxLength="14" style="width:120px;" onKeyUp="this.value=formatPhoneNumber(this.value);"', '', html_after_input_field);
}

function createAddressField(id, name, label, street, city, state, zip, options)
{
	if(!empty(id))
		id += '_';
		
	var innerHTML = ''
+'		<z:field>'
+'			<label for="' + id + name + '_street">' + label + '</label>'
+'			<input id="' + id + name + '_street" type="text" name="' + name + '_street" value="' + street + '" />'
+'		</z:field>'
+'		<z:field>'
+'			<label for="' + id + name + '_city">&nbsp;</label>'
+'			<input id="' + id + name + '_city" type="text" name="' + name + '_city" value="' + city + '" style="width:140px;" />'
+'			<select id="' + id + name + '_state" name="' + name + '_state">' + (typeof(value) != 'undefined' ? createSelectOptions(options, value) : createSelectOptions(options))
+'			</select>'
+'			<input id="' + id + name + '_zip" type="text" name="' + name + '_zip" value="' + zip + '" maxLength="5" style="width:50px;" onKeyUp="this.value=numbersOnly(this.value);" />'
+'			<span class="error_span"></span>'
+'		</z:field>';

	return innerHTML;
}

function createToggleCheckbox(id, name, label, value, onclick)
{
	if(typeof(value) == 'undefined')
		value = '';
	if(typeof(onclick) == 'undefined')
		onclick = '';

	return createInput('checkbox', id, name, value, 'onclick="' + onclick + '"') + '<a href="#nogo" onclick="$(\'' + id + '\').click();">' + label + '</a>';
}


function createSelectOptions(options, value)
{
	var innerHTML = '';
	if(typeof(options) == 'object')
	{
		foreach(options, function(option, key)
		{
			innerHTML += ''
+'				<option value="' + key + '" ' + (value == key ? 'selected="selected"' : '') + '>' + option + '</option>';
        });
	} 
	else
	{
		if(options.indexOf('value="' + value + '"') != -1)
		{
			var split = options.split('value="' + value + '"');
			options = split[0] + 'value="' + value + '" selected="selected"' + split[1];
		}
				
		innerHTML += options;
	}
	
	return innerHTML;
}

function createInput(type, id, name, value, input_attributes, options)
{
	if(typeof(value) == 'undefined')
		value = '';

	if(typeof(input_attributes) == 'undefined')
		input_attributes = '';
		
	if(typeof(options) == 'undefined')
		options = '';
		
	string = '';
	switch(type.toLowerCase())
	{
		case 'text'		: string += ''
+'			<input id="' + id + '" type="text" name="' + name + '" value="' + value + '" ' + displayIfNotEmpty(input_attributes) + ' />'; break;
		case 'textarea'	: string += ''
+'			<textarea id="' + id + '" name="' + name + '" ' + displayIfNotEmpty(input_attributes) + '>' + value + '</textarea>'; break;
		case 'select'	: string += ''
+'			<select id="' + id + '" name="' + name + '" ' + displayIfNotEmpty(input_attributes) + '>'
+'				' + createSelectOptions(options, value)
+'			</select>'; break;

		//JS is f'd up sometimes - (value != false) is not the same as (value). the string "0" is read as true in the latter
		case 'checkbox'	: string += ''
+'			<input id="' + id + '" type="checkbox" name="' + name + '" ' + ((value != false) ? 'CHECKED' : '') + ' class="checkbox" ' + displayIfNotEmpty(input_attributes) + ' />'; break;
		case 'radio'	: 
			var i=0;
			var orig_id = id;
			var key;
			for(key in options)
			{
				id = orig_id + i++;
				string += ''
+'			<input id="' + id + '" type="radio" name="' + name + '" value="' + key + '" class="radio" ' + (key == value ? ' CHECKED ' : '') + displayIfNotEmpty(input_attributes) + ' /><a href="#nogo" onclick="$(\'' + id + '\')+click();">' + options[key] + '</a>';
			}
			 break;
		case 'file'		: string += ''
+'			<input id="' + id + '" type="file" name="' + name + '" class="file" ' + displayIfNotEmpty(input_attributes) + ' />'; break;
		case 'submit'	: string += ''
+'			<input id="' + id + '" type="submit" name="' + name + '" value="' + value + '" class="button" ' + displayIfNotEmpty(input_attributes) + ' />'; break;
	}
	
	return string;
}

function updateDisplayFields()
// Updates display input fields to entered input fields
// Display input field is the uneditable version of an input field (when you want to toggle between display and input)
// Must be called with the input field ids as parameters
// All inputs must be labeled id='[name]'
// All display inputs must be labeled id='display_[name]'
{
	var i;
	for(i=0; i < arguments.length; i++)
	{
		field = $(arguments[i]);
		var display = 'display_' + input;
		var display_element = $(display);
		var value = getFieldValue(field);
		display_element.innerHTML = value;
	}
}

function setFormValuesFromViewSpans(form)
{
	var fields = getFormFields(form);

	var i;
	var field_id;
	for(i=0; i<fields.length; i++)
	{
		if(
			(field_id = fields[i].getAttribute('id')) &&
  		(view_span = $(field_id + '_view')) && 
  		view_span.firstChild
  	)
			setFormValue(field_id, view_span.firstChild.nodeValue);
	}
}

//global_defines.js

var user_agent = navigator.userAgent.toLowerCase();
var is_ie = false;
var is_ie7 = false;
var is_ie6 = false;
var is_ff = false;
var is_opera = false;

is_opera = (user_agent.indexOf("opera") != -1);
if(!is_opera)
{
    is_ie = (user_agent.indexOf("msie") != -1);
    if(is_ie)
    {
        if(!(is_ie7 = (user_agent.indexOf("msie 7.0") != -1)));
            is_ie6 = (user_agent.indexOf("msie 6.0") != -1);
    }
    else
    {
		is_ff = (user_agent.indexOf("mozilla") != -1);
	}
}

// image.js

function setImageMaxSize(image, width, height, max_width, max_height)
{
	var new_height;
	var new_width;

  	// If no max set, or width and height are less than max, no need to resize
  	if(
  		(empty(max_width) && empty(max_height)) || 
  		(
  			(empty(max_width) || (width < max_width)) && 
  			(empty(max_height) || (height < max_height))
  		)
  	)
  	{
  		new_width = width;
  		new_height = height;
  	}
  	
  	else if
  	(
  		// if only max_width set
  		(!empty(max_width) && empty(max_height)) || 

  		// if max_width and max_height set
  		(!empty(max_width) && !empty(max_height) && 
  			(
  				// if wider but not taller
  				(width > max_width && height <= max_height) ||
  				
  				// if wider and taller, and proportionally wider
  				(width > max_width && height > max_height && (width / height >= max_width / max_height))
  			)
  		)
  	)
  	{
  		scale = max_width / width;
  		new_width = max_width;
  		new_height = height * scale;
  	}			

  	else if
  	(
  		// if only max_height set
  		(!empty(max_height) && empty(max_width)) || 

  		// if max_height and max_width set
  		(!empty(max_height) && !empty(max_width) && 
  			(
  				// if taller but not wider
  				(height > max_height && width <= max_width) ||
  				
  				// if taller and wider, and proportionally taller
  				(height > max_height && width > max_width && (height / width >= max_height / max_width))
  			)
  		)
  	)
  	{
  		scale = max_height / height;
  		new_width = width * scale;
  		new_height = max_height;		
  	}
		
	image.style.width = new_width + 'px';
	image.style.height = new_height + 'px';
}

// legacy.js

function replaceAll(regexp, replacement, str) { return str.replace(regexp + '/g', replacement); }
function getFieldValue(field) { return getFormValue(field); }
function isChecked(field) { return getFormValue(field); }


// mail.js

function addFormAttachment(form)
{
	if(!(form = getElement(form)))
		return false;

	var i=1;
	while(document.getElementById('attachment' + i))
		i++;

	var field = document.createElement('dl');
	field.className = 'contain_floats';

	field.setAttribute('id', 'attachment' + i);
	field.innerHTML = '<dt><label for="attachment' + i + '">Attachment ' + i + '</label></dt><dd><input type="file" name="attachment' + i + '" class="file" /> <a href="#nogo" onclick="myRemoveNode(this.parentNode.parentNode);"><small>Remove Attachment</small></a></dd>';

	insertBefore(field, getElement('add_attachment_field'));
}


//deprecated, but still in use
function addAttachment(form)
{
	if(!(form = getElement(form)))
		return false;

	var i=1;
	while(document.getElementById('attachment' + i))
		i++;

	var field = document.createElement('z:field');

	field.setAttribute('id', 'attachment' + i);
	field.innerHTML = '<label for="attachment' + i + '">Attachment ' + i + ':</label><input type="file" name="attachment' + i + '" class="file" /> <a href="#nogo" onclick="myRemoveNode(this.parentNode);"><small>Remove Attachment</small></a>';

	insertBefore(field, getElement('add_attachment_field'));
}

// php_unserialize.js

function package(data) { return escape(serialize(data)); }
function unPackage(data) 
{
	if(typeof(data) != 'string')
	    return data;
	
	var data = unescape(data);
		
	return my_unserialize(data); 
}

function serialize(data) 
{
  var Encoder = new JPSpan_Encode_PHP();
	return Encoder.encode(data);
}

function unserialize(data)
{
  var result = PHP_Unserialize_(data);
	return result[0];
}

function my_unserialize(data)
{
	if(data == 'b:0;')
		return false;
		
	var result;
	if(!(result = PHP_Unserialize_(trim(data))))
		return data;

	var unserialized_data = (result[0]) ? result[0] : data;
	return unserialized_data;
}

/**
* Function which performs the actual unserializing
*
* @param string input Input to parse
*/

function PHP_Unserialize_(input)
{
    if(typeof input != 'string' || empty(input))
        return '';

// This was causing infinite looping somehow. Will re-implement if problems arise.
//	if(!(String(input).match(/^[a-z]{1}.*[\}\;]+$/i)))
//		return false;

	var length = 0;
	   
	switch (input.charAt(0)) {
		/**
		* Array
		*/
		case 'a':
			length = PHP_Unserialize_GetLength(input);
			input  = input.substr(String(length).length + 4);

			var arr   = new Array();
			var key   = null;
			var value = null;

			for (var i=0; i<length; ++i) {
				key   = PHP_Unserialize_(input);
				input = key[1];

				value = PHP_Unserialize_(input);
				input = value[1];

				arr[key[0]] = value[0];
			}

			input = input.substr(1);
			return [arr, input];
			break;
		
		/**
		* Objects
		*/
		case 'O':
			length = PHP_Unserialize_GetLength(input);
			var classname = String(input.substr(String(length).length + 4, length));
			
			input  = input.substr(String(length).length + 6 + length);
			var numProperties = Number(input.substring(0, input.indexOf(':')))
			input = input.substr(String(numProperties).length + 2);

			var obj	  = new Object();
			var property = null;
			var value	= null;

			for (var i=0; i<numProperties; ++i) {
				key   = PHP_Unserialize_(input);
				input = key[1];
				
				// Handle private/protected
				key[0] = key[0].replace(new RegExp('^\x00' + classname + '\x00'), '');
				key[0] = key[0].replace(new RegExp('^\x00\\*\x00'), '');

				value = PHP_Unserialize_(input);
				input = value[1];

				obj[key[0]] = value[0];
			}

			input = input.substr(1);
			return [obj, input];
			break;

		/**
		* Strings
		*/
		case 's':
			length = PHP_Unserialize_GetLength(input);
			return [String(input.substr(String(length).length + 4, length)), input.substr(String(length).length + 6 + length)];
			break;

		/**
		* Integers and doubles
		*/
		case 'i':
		case 'd':
			var num = Number(input.substring(2, input.indexOf(';')));
			return [num, input.substr(String(num).length + 3)];
			break;
		
		/**
		* Booleans
		*/
		case 'b':
			var bool = (input.substr(2, 1) == 1);
			return [bool, input.substr(4)];
			break;
		
		/**
		* Null
		*/
		case 'N':
			return [null, input.substr(2)];
			break;

		/**
		* Unsupported
		*/
		case 'o':
		case 'r':
		case 'C':
		case 'R':
		case 'U':
			alert('Error: Unsupported PHP data type found!');

		/**
		* Error
		*/
		default:
			return [false, null]; // *Kirk - changed from [null, null] to [false, null]
			break;
	}
}


/**
* Returns length of strings/arrays etc
*
* @param string input Input to parse
*/
function PHP_Unserialize_GetLength(input)
{
	input = input.substring(2);
	var length = Number(input.substr(0, input.indexOf(':')));
	return length;
}

function JPSpan_Encode_PHP() {
	this.Serialize = new JPSpan_Serialize(this);
};

JPSpan_Encode_PHP.prototype = {

	// Used by rawpost request objects
	contentType: 'text/plain; charset=US-ASCII',
	
	encode: function(data) {
		return this.Serialize.serialize(data);
	},
	
	encodeInteger: function(v) {
		return 'i:'+v+';';
	},
	
	encodeDouble: function(v) {
		return 'd:'+v+';';
	},
	
	encodeString: function(v) {
		var s = ''
		for(var n=0; n<v.length; n++) {
			var c=v.charCodeAt(n);
			// Ignore everything but ASCII
			if (c<128) {
				s += String.fromCharCode(c);
			}
		}
		return 's:'+s.length+':"'+s+'";';
	},
	
	encodeNull: function() {
		return 'N;';
	},
	
	encodeTrue: function() {
		return 'b:1;';
	},
	
	encodeFalse: function() {
		return 'b:0;';
	},
	
	encodeArray: function(v, Serializer) {
		var indexed = new Array();
		var count = v.length;
		var s = '';
		for (var i=0; i<v.length; i++) {
			indexed[i] = true;
			s += 'i:'+i+';'+Serializer.serialize(v[i]);
		};

		for ( var prop in v ) {
			if ( indexed[prop] ) {
				continue;
			};
			s += Serializer.serialize(prop)+Serializer.serialize(v[prop]);
			count++;
		};
		
		s = 'a:'+count+':{'+s;
		s += '}';
		return s;
	},
	
	encodeObject: function(v, Serializer, cname) {
		var s='';
		var count=0;
		for (var prop in v) {
			s += 's:'+prop.length+':"'+prop+'";';
			if (v[prop]!=null) {
				s += Serializer.serialize(v[prop]);
			} else {
				s +='N;';
			};
			count++;
		};
		s = 'O:'+cname.length+':"'+cname.toLowerCase()+'":'+count+':{'+s+'}';   
		return s;
	},
	
	encodeError: function(v, Serializer, cname) {
		var e = new Object();
		if ( !v.name ) {
			e.name = cname;
			e.message = v.description;
		} else {
			e.name = v.name;
			e.message = v.message;
		};
		return this.encodeObject(e,Serializer,cname);
	}
}// Id: serialize.js,v 1.5 2004/11/21 11:14:05 harryf Exp 
// Notes:
// - Watch out for recursive references - call inside a try/catch block if uncertain
// - Objects are serialized to PHP class name JPSpan_Object by default
// - Errors are serialized to PHP class name JPSpan_Error by default
//
// See discussion below for notes on Javascript reflection
// http://www.webreference.com/dhtml/column68/
function JPSpan_Serialize(Encoder) {
	this.Encoder = Encoder;
	this.typeMap = new Object();
};

JPSpan_Serialize.prototype = {

	typeMap: null,
	
	addType: function(cname, callback) {
		this.typeMap[cname] = callback;
	},
	
	serialize: function(v) {
	
		switch(typeof v) {
			//-------------------------------------------------------------------
			case 'object':
			
				// It's a null value
				if ( v === null ) {
					return this.Encoder.encodeNull();
				}
				
				// Get the constructor
				var c = v.constructor;
				
				if (c != null ) {
				
					// It's an array
					if ( c == Array ) {
						return this.Encoder.encodeArray(v,this);
					} else {
					
						// Get the class name
						var match = String(c).match( /\s*function (.*)\(/ );

						if ( match == null ) {
							return this.Encoder.encodeObject(v,this,'JPSpan_Object');
						}
						
						// Strip space for IE
						var cname = match[1].replace(/\s/,'');
						
						// Has the user registers a callback for serializing this class?
						if ( this.typeMap[cname] ) {
							return this.typeMap[cname](v, this, cname);
							
						} else {
							// Check for error objects
							var match = cname.match(/Error/);
						
							if ( match == null ) {
								return this.Encoder.encodeObject(v,this,'JPSpan_Object');
							} else {
								return this.Encoder.encodeError(v,this,'JPSpan_Error');
							}

						}
					}
				} else {
					// Return null if constructor is null
					return this.Encoder.encodeNull();
				}
			break;
			
			//-------------------------------------------------------------------
			case 'string':
				return this.Encoder.encodeString(v);
			break;
			
			//-------------------------------------------------------------------
			case 'number':
				if (Math.round(v) == v) {
					return this.Encoder.encodeInteger(v);
				} else {
					return this.Encoder.encodeDouble(v);
				};
			break;
			
			//-------------------------------------------------------------------
			case 'boolean':
				if (v == true) {
					return this.Encoder.encodeTrue();
				} else {
					return this.Encoder.encodeFalse();
				};
			break;
			
			//-------------------------------------------------------------------
			default:
				return this.Encoder.encodeNull();
			break;
		}
	}
}

// Id: data.js,v 1.2 2004/11/12 22:27:23 harryf Exp 
function JPSpan_Util_Data() {
	this.Serialize = new JPSpan_Serialize(this);
	this.indent = '';
};

JPSpan_Util_Data.prototype = {
	dump: function(data) {
		return this.Serialize.serialize(data);
	},
	
	encodeInteger: function(v) {
		return 'Integer: '+v+"\n";
	},
	
	encodeDouble: function(v) {
		return 'Double: '+v+"\n";
	},
	
	encodeString: function(v) {
		return 'String('+v.length+'): '+v+"\n";
	},
	
	encodeNull: function() {
		return "Null\n";
	},
	
	encodeTrue: function() {
		return "Boolean(true)\n"
	},
	
	encodeFalse: function() {
		return "Boolean(false)\n"
	},
	
	encodeArray: function(v, Serializer) {
		var a=v;
		var indexed = new Array();
		var out='Array('+a.length+")\n";
		this.indent += '  ';
		if ( a.length>0 ) {
			for (var i=0; i < a.length; i++) {
				indexed[i] = true;
				out+=this.indent+'['+i+']';
				if ( (a[i]+'') == 'undefined') {
					out+= " = undefined\n";
					continue;
				};
				out+= ' = '+Serializer.serialize(a[i])+"\n";
			};
		};
		var assoc='';
		for ( var prop in a ) {
			if ( indexed[prop] ) {
				continue;
			};
			assoc+=this.indent+'["'+prop+'"]';
			if ( (a[prop]+'') == 'undefined') {
				assoc+= " = undefined\n";
				continue;
			};
			assoc+= ' = '+Serializer.serialize(a[prop])+"\n";
		};
		if ( assoc.length > 0 ) {
			out += assoc;
		};
		this.indent = this.indent.substr(0,this.indent.length-2);
		return out;
	},
	
	encodeObject: function(v, Serializer, cname) {
		var o=v;
		if (o==null) return "Null\n";
		var out='Object('+cname+")\n";
		this.indent += '  ';
		for (var prop in o) {
			out+=this.indent+'.'+prop+' = ';
			if (o[prop]==null) {
				out+="null\n";
				continue;
			};
			out+=Serializer.serialize(o[prop])+"\n";
		};
		this.indent = this.indent.substr(0,this.indent.length-2);
		return out;
	},
	
	encodeError: function(v, Serializer, cname) {
		var e = new Object();
		if ( !v.name ) {
			e.name = cname;
			e.message = v.description;
		} else {
			e.name = v.name;
			e.message = v.message;
		};
		return this.encodeObject(e,Serializer,cname);
	}
};

// string.js

function echo(string) {	document.write(string); }
function nl2br(string) { return string.replace(/\n/g, '<br />'); }
function br2nl(string) { return string.replace(/\<br *\/?\>/g, '\n'); }

function strip_tags(string) 
    { return string.replace(/<\/?[^>]+>/gi, ''); }

function displayIfNotEmpty(string, pattern)
{
	if(empty(string))
		return '';

	return (!empty(pattern)) ? pattern.replace(/\_STRING\_/, string) : string;
}

function makePlural(string) { return string + 's'; } //Works for now
function makePossessive(string)
{
	string = rtrim(string);
	var last_letter = string.indexOf(string.length-1);
	return string + ((last_letter.toLowerCase == 's') ? "'" : "'s");
}

function strcasecmp(string1, string2)
{
	string1 = String(string1).toLowerCase();
	string2 = String(string2).toLowerCase();
	if(string1 < string2)
		return -1;
	if(string1 == string2)
		return 0;
	return 1;
}

function substr(string, start, length)
{
    if (start < 0)
    {
        start = (string.length + start);
        length = (string.length - start);
    }
    
    return string.substr(start, length); 
}

function substr_count(string, substr)
{
    var count = 0;
    var last_index = -1;
    while ( (last_index = string.indexOf("\n", last_index + 1)) != -1 ) 
    {
        count++;
    }
    return count;
}

function str_pad(input, pad_length, pad_string, pad_type)
{
	input = String(input);
	
	if(typeof(pad_string) == 'undefined')
		var pad_string = '&nbsp;';
		
pad_string = String(pad_string);
	pad_length = Number(pad_length);  		
var pad_type = pad_type || 'STR_PAD_LEFT';

	while(input.length < pad_length)
	{
		if(pad_type == 'STR_PAD_LEFT')
			input = pad_string + input;
		else if(pad_type == 'STR_PAD_RIGHT')
			input = input + pad_string;
	}

	return input;
}

function setDecimal(number, decimal_places) 
{
	var str = String(number);
	var before = str;
	var after = '';
	
	if(str.indexOf('.') != -1)
	{
		var split = str.split('.');
		var before = split[0];
		var after = split[1];
	}

	after = after.substr(0, decimal_places);
	return before.replace(/^0*/g, '') + ('' == before ? '0' : '') + (decimal_places != 0 ? '.' : '') + strPad(after, decimal_places, '0', 'STR_PAD_RIGHT');
}

function truncateAtDecimal(number, decimal_places) { return Math.floor(number * Math.pow(10, decimal_places)) / Math.pow(10, decimal_places); }

function formatMoneyInput(value)
{
	if(value.replace(/0*/, '') == '')
		return '0.00';
		
	return setDecimal(value, 2);
}

function preg_replace(regexp, replacement, string)
{
	if(regexp.toString().match(/\/[^g]*$/))
	{
		var regexp_string = regexp.toString();
		var split = regexp_string.split('/');
		var flags = split[split.length-1];
		
		if(flags.indexOf('g') == -1)
		{
			var pattern = regexp_string.replace(/\/[^\/]*$/, '').replace(/^\/{1}/, '');
			regexp = new RegExp(pattern, flags + 'g');
		}
	}

	return string.replace(regexp, replacement);
}

function addslashes(string) 
{
	string = string.replace(/\\/g,'\\\\');
	string = string.replace(/\'/g,'\\\'');
	string = string.replace(/\"/g,'\\"');
	string = string.replace(/\0/g,'\\0');
	return string;
}

function stripslashes(string) 
{
	string = string.replace(/\\\\/g,'\\');
	string = string.replace(/\\'/g,'\'');
	string = string.replace(/\\"/g,'"');
	string = string.replace(/\\0/g,'\0');
	return string;
}


function trim(string, char_list) 
{ 
	if(typeof(char_list) == 'undefined') 
		char_list = ''; 
	var match = '[' + char_list + '\\s]*';
	var pattern = new RegExp('^' + match + '|' + match + '$', 'g'); 
	return string.replace(pattern,''); 
}
function ltrim(string, char_list) 
{ 
	if(typeof(char_list) == 'undefined') 
		char_list = ''; 
	var match = '[' + char_list + '\\s]*';
	var pattern = new RegExp('^' + match, 'g'); 
	return string.replace(pattern,''); 
}

function rtrim(string, char_list) 
{ 
	if(typeof(char_list) == 'undefined') 
		char_list = ''; 
	var match = '[' + char_list + '\\s]*';
	var pattern = new RegExp(match + '$', 'g'); 
	return string.replace(pattern,''); 
}

function strstr(search_string, string)
{
	var pattern = new RegExp(search_string + '.*$'); 
	return String(string).match(pattern);
}
function stristr(search_string, string) 
{ 
	var pattern = new RegExp(search_string + '.*$', 'i'); 
	return String(string).match(pattern);
}

function prefixWord(prefix, word)
{
	var first_letter_is_vowel = word.match(/^[aeiou]{1}/i)
	var new_prefix = '';
		
	switch(prefix.toLowerCase())
	{
		case 'a' : new_prefix = (first_letter_is_vowel) ? prefix + 'n' : prefix; break;
	}
	
	return new_prefix + ' ' + word;
}

function ucwords(string)
{
	if(empty(string))
		return '';

	var new_string = string.charAt(0).toUpperCase();

	for(i=1; i<string.length; i++)
	{
		if(string.charAt(i-1).match(/[ \t\n]/))
			new_string += string.charAt(i).toUpperCase();
		else
			new_string += string.charAt(i);
	}

	return new_string;
}

function strPad(string, pad_length, pad_string, pad_type)
{
	string = String(string);
	
	if(typeof(pad_string) == 'undefined')
		var pad_string = '&nbsp;';
		
    pad_string = String(pad_string);
	pad_length = Number(pad_length);  		
    var pad_type = pad_type || 'STR_PAD_LEFT';

	while(string.length < pad_length)
	{
		if(pad_type == 'STR_PAD_LEFT')
			string = pad_string + string;
		else if(pad_type == 'STR_PAD_RIGHT')
			string = string + pad_string;
	}

	return string;
}

function formatPhoneNumber(phone_number)
{
	var numbers_only = phone_number.replace(/[^0-9]/g, '');
	var length = numbers_only.length;
	if(length == 0)
		return '';

	var formatted_phone_number = '(' + numbers_only.substr(0, 3);
	if(length >= 4)
		formatted_phone_number += ') ' + numbers_only.substr(3, 3);
	if(length >= 7)
		formatted_phone_number += '-' + numbers_only.substr(6, 4);	
	return formatted_phone_number;
}

function formatSocialSecurityNumber(social_security_number)
{
	var numbers_only = social_security_number.replace(/[^0-9]/g, '');
	var length = numbers_only.length;
	if(length == 0)
		return '';

	var formatted_social_security_number = numbers_only.substr(0, 3);
	if(length >= 4)
		formatted_social_security_number += '-' + numbers_only.substr(3, 2);
	if(length >= 6)
		formatted_social_security_number += '-' + numbers_only.substr(5, 4);
	return formatted_social_security_number;
}

function numbersOnly(string) { return string.replace(/[^0-9-]/g, ''); }
function floatNumbersOnly(string) {	return string.replace(/[^0-9.-]/g, ''); }

function formatDollars(string)
{
	string = setDecimal(floatNumbersOnly(string), 2);
	if(string.substr(0, 1) == '.')
		string = 0 + string;
	return string;
}

function charFromCharCode (charCode) 
{
    return unescape('%' + charCode.toString(16));
}

function urlencode (clearString) 
{
  var output = '';
  var x = 0;
  clearString = clearString.toString();
  var regex = /(^[a-zA-Z0-9_.]*)/;
  while (x < clearString.length) {
    var match = regex.exec(clearString.substr(x));
    if (match != null && match.length > 1 && match[1] != '') {
    	output += match[1];
      x += match[1].length;
    } else {
      if (clearString[x] == ' ')
        output += '+';
      else {
        var charCode = clearString.charCodeAt(x);
        var hexVal = charCode.toString(16);
        output += '%' + ( hexVal.length < 2 ? '0' : '' ) + hexVal.toUpperCase();
      }
      x++;
    }
  }
  return output;
}

function urldecode (encodedString) {
  var output = encodedString;
  var binVal, thisString;
  var myregexp = /(%[^%]{2})/;
  while ((match = myregexp.exec(output)) != null
             && match.length > 1
             && match[1] != '') {
    binVal = parseInt(match[1].substr(1),16);
    thisString = String.fromCharCode(binVal);
    output = output.replace(match[1], thisString);
  }
  return output;
}

/*
        TableSort revisited v4.5 by frequency-decoder.com

        Released under a creative commons Attribution-ShareAlike 2.5 license (http://creativecommons.org/licenses/by-sa/2.5/)

        Please credit frequency decoder in any derivative work - thanks

        You are free:

        * to copy, distribute, display, and perform the work
        * to make derivative works
        * to make commercial use of the work

        Under the following conditions:

                by Attribution.
                --------------
                You must attribute the work in the manner specified by the author or licensor.

                sa
                --
                Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under a license identical to this one.

        * For any reuse or distribution, you must make clear to others the license terms of this work.
        * Any of these conditions can be waived if you get permission from the copyright holder.
*/

(function() {

fdTableSort = {
        regExp_Currency:        /^[£$€¥¤]/,
        regExp_Number:          /^(\-)?[0-9]+(\.[0-9]*)?$/,
        pos:                    -1,
        uniqueHash:             1,
        thNode:                 null,
        tableId:                null,
        tableCache:             {},
        tmpCache:               {},

        /*@cc_on
        /*@if (@_win32)
        colspan:                "colSpan",
        rowspan:                "rowSpan",
        @else @*/
        colspan:                "colspan",
        rowspan:                "rowspan",
        /*@end
        @*/

        addEvent: function(obj, type, fn, tmp) {
                tmp || (tmp = true);
                if( obj.attachEvent ) {
                        obj["e"+type+fn] = fn;
                        obj[type+fn] = function(){obj["e"+type+fn]( window.event );};
                        obj.attachEvent( "on"+type, obj[type+fn] );
                } else {
                        obj.addEventListener( type, fn, true );
                };
        },
        removeEvent: function(obj, type, fn, tmp) {
                tmp || (tmp = true);
                try {
                        if( obj.detachEvent ) {
                                obj.detachEvent( "on"+type, obj[type+fn] );
                                obj[type+fn] = null;
                        } else {
                                obj.removeEventListener( type, fn, true );
                        };
                } catch(err) {};
        },
        stopEvent: function(e) {
                e = e || window.event;

                if(e.stopPropagation) {
                        e.stopPropagation();
                        e.preventDefault();
                };
                /*@cc_on@*/
                /*@if(@_win32)
                e.cancelBubble = true;
                e.returnValue  = false;
                /*@end@*/
                return false;
        },
        parseClassName: function(head, tbl) {
                var colMatch = tbl.className.match(new RegExp(head + "((-[\\d]+([r]){0,1})+)"));
                return colMatch && colMatch.length ? colMatch[0].replace(head, "").split("-") : [];
        },
        disableSelection: function(element) {
                element.onselectstart = function() {
                        return false;
                };
                element.unselectable = "on";
                element.style.MozUserSelect = "none";
        },
        removeTableCache: function(tableId) {
                if(!(tableId in fdTableSort.tableCache)) return;

                fdTableSort.tableCache[tableId] = null;
                delete fdTableSort.tableCache[tableId];

                var tbl = document.getElementById(tableId);
                if(!tbl) return;
                var ths = tbl.getElementsByTagName("th");
                var a;
                for(var i = 0, th; th = ths[i]; i++) {
                        a = th.getElementsByTagName("a");
                        if(a.length) a[0].onkeydown = a[0].onclick = null;
                        th.onclick = th.onselectstart = th = a = null;
                };
        },
        removeTmpCache: function(tableId) {
                if(!(tableId in fdTableSort.tmpCache)) return;
                var headers = fdTableSort.tmpCache[tableId].headers;
                var a;
                for(var i = 0, row; row = headers[i]; i++) {
                        for(var j = 0, th; th = row[j]; j++) {
                                a = th.getElementsByTagName("a");
                                if(a.length) a[0].onkeydown = a[0].onclick = null;
                                th.onclick = th.onselectstart = th = a = null;
                        };
                };
                fdTableSort.tmpCache[tableId] = null;
                delete fdTableSort.tmpCache[tableId];
        },
        initEvt: function(e) {
                fdTableSort.init(false);
        },
        init: function(tableId) {
                if (!document.getElementsByTagName || !document.createElement || !document.getElementById) return;

                var tables = tableId && document.getElementById(tableId) ? [document.getElementById(tableId)] : document.getElementsByTagName("table");
                var c, ii, len, onLoadSort, colMatch, showOnly, match, showArrow, columnNumSortObj, obj, workArr, headers, thtext, aclone, multi, colCnt, cel, allRowArr, rowArr, sortableTable, celCount, colspan, rowspan, rowLength;

                var a          = document.createElement("a");
                a.href         = "#";
                a.className    = "fdTableSortTrigger";
                
                var span       = document.createElement("span");

                for(var k = 0, tbl; tbl = tables[k]; k++) {

                        // Remove any old dataObj for this table (tables created from an ajax callback require this)
                        if(tbl.id) fdTableSort.removeTableCache(tbl.id);

                        // Remove any old tmpCache object for this table
                        if(tbl.id) fdTableSort.removeTmpCache(tbl.id);

                        allRowArr     = tbl.getElementsByTagName('thead').length ? tbl.getElementsByTagName('thead')[0].getElementsByTagName('tr') : tbl.getElementsByTagName('tr');
                        rowArr        = [];
                        sortableTable = false;

                        // Grab only the tr's that contain no td's and check at least one th has the class "sortable"
                        for(var i = 0, tr; tr = allRowArr[i]; i++) {
                                if(tr.getElementsByTagName('td').length || !tr.getElementsByTagName('th').length) continue;
                                rowArr[rowArr.length] = tr.getElementsByTagName('th');
                                for(var j = 0, th; th = rowArr[rowArr.length - 1][j]; j++) {
                                        if(th.className.search(/sortable/) != -1) sortableTable = true;
                                };
                        };

                        if(!sortableTable) continue;

                        if(!tbl.id) tbl.id = "fd-table-" + fdTableSort.uniqueHash++;

                        onLoadSort  = {};
                        showArrow   = tbl.className.search(/no-arrow/) == -1;
                        showOnly    = tbl.className.search("sortable-onload-show") != -1;

                        columnNumSortObj = {};
                        colMatch         = fdTableSort.parseClassName(showOnly ? "sortable-onload-show" : "sortable-onload", tbl);
                        for(match = 1; match < colMatch.length; match++) {
                                columnNumSortObj[parseInt(colMatch[match])] = colMatch[match].search("r") != -1;
                        };
                        
                        rowLength = rowArr[0].length;

                        for(c = 0;c < rowArr[0].length;c++){
                                if(rowArr[0][c].getAttribute(fdTableSort.colspan) && rowArr[0][c].getAttribute(fdTableSort.colspan) > 1){
                                        rowLength = rowLength + (rowArr[0][c].getAttribute(fdTableSort.colspan) - 1);
                                };
                        };

                        workArr = new Array(rowArr.length);

                        for(c = rowArr.length;c--;){
                                workArr[c]= new Array(rowLength);
                        };

                        for(c = 0;c < workArr.length;c++){
                                celCount = 0;
                                for(i = 0;i < rowLength;i++){
                                        if(!workArr[c][i]){
                                                cel = rowArr[c][celCount];
                                                colspan = (cel.getAttribute(fdTableSort.colspan) > 1) ? cel.getAttribute(fdTableSort.colspan):1;
                                                rowspan = (cel.getAttribute(fdTableSort.rowspan) > 1) ? cel.getAttribute(fdTableSort.rowspan):1;
                                                for(var t = 0;((t < colspan)&&((i+t) < rowLength));t++){
                                                        for(var n = 0;((n < rowspan)&&((c+n) < workArr.length));n++) {
                                                                workArr[(c+n)][(i+t)] = cel;
                                                        };
                                                };
                                                if(++celCount == rowArr[c].length) break;
                                        };
                                };
                        };

                        for(c = 0;c < workArr.length;c++) {
                                for(i = 0;i < workArr[c].length;i++){

                                        if(workArr[c][i].className.search("fd-column-") == -1 && workArr[c][i].className.search("sortable") != -1) workArr[c][i].className = workArr[c][i].className + " fd-column-" + i;

                                        if(workArr[c][i].className.match('sortable')) {
                                                workArr[c][i].className = workArr[c][i].className.replace(/forwardSort|reverseSort/, "");

                                                if(i in columnNumSortObj && !("column-" + i in onLoadSort)) {
                                                        onLoadSort["column-" + i] = {
                                                                "thNode":workArr[c][i],
                                                                "reverse":columnNumSortObj[i]
                                                        };
                                                        onLoadSort["active"] = true;
                                                };

                                                thtext = fdTableSort.getInnerText(workArr[c][i]);

                                                for(var cn = workArr[c][i].childNodes.length; cn--;) {
                                                        // Skip image nodes and links created by the filter script.
                                                        if(workArr[c][i].childNodes[cn].nodeType == 1 && (workArr[c][i].childNodes[cn].className == "fdFilterTrigger" || /img/i.test(workArr[c][i].childNodes[cn].nodeName))) {
                                                                continue;
                                                        };
                                                        if(workArr[c][i].childNodes[cn].nodeType == 1 && /^a$/i.test(workArr[c][i].childNodes[cn].nodeName)) {
                                                                workArr[c][i].childNodes[cn].onclick = workArr[c][i].childNodes[cn].onkeydown = null;
                                                        };
                                                        workArr[c][i].removeChild(workArr[c][i].childNodes[cn]);
                                                };

                                                // Create the link
                                                aclone = a.cloneNode(true);
                                                aclone.appendChild(document.createTextNode(thtext));
                                                aclone.title = "Sort on \u201c" + thtext + "\u201d";
                                                aclone.onclick = aclone.onkeydown = workArr[c][i].onclick = fdTableSort.initWrapper;
                                                workArr[c][i].appendChild(aclone);

                                                // Add the span if needs be
                                                if(showArrow) workArr[c][i].appendChild(span.cloneNode(false));

                                                workArr[c][i].className = workArr[c][i].className.replace(/fd-identical|fd-not-identical/, "");
                                                fdTableSort.disableSelection(workArr[c][i]);
                                                aclone = null;
                                        };
                                };
                        };

                        fdTableSort.tmpCache[tbl.id] = {cols:rowLength, headers:workArr};

                        workArr = null;
                        multi   = 0;
                        
                        if("active" in onLoadSort) {
                                fdTableSort.tableId = tbl.id;
                                fdTableSort.prepareTableData(document.getElementById(fdTableSort.tableId));
                                delete onLoadSort.active;

                                for(col in onLoadSort) {
                                        fdTableSort.multi = multi > 0 ? true : false;
                                        obj = onLoadSort[col];
                                        len = obj.reverse ? 2 : 1;

                                        for(ii = 0; ii < len; ii++) {
                                                fdTableSort.thNode = obj.thNode;
                                                if(!showOnly) {
                                                        fdTableSort.initSort();
                                                } else {
                                                        fdTableSort.addThNode();
                                                };
                                        };
                                        
                                        if(showOnly) {
                                                fdTableSort.removeClass(obj.thNode, "(forwardSort|reverseSort)");
                                                fdTableSort.addClass(obj.thNode, obj.reverse ? "reverseSort" : "forwardSort");
                                                if(showArrow) {
                                                        span = fdTableSort.thNode.getElementsByTagName('span')[0];
                                                        if(span.firstChild) span.removeChild(span.firstChild);
                                                        span.appendChild(document.createTextNode(len == 1 ? " \u2193" : " \u2191"));
                                                };
                                        };
                                        
                                        multi++;
                                };
                                
                                if(showOnly && (fdTableSort.tableCache[tbl.id].colStyle || fdTableSort.tableCache[tbl.id].rowStyle)) {
                                        fdTableSort.redraw(tbl.id, false);
                                };
                        } else if(tbl.className.search(/onload-zebra/) != -1) {
                                fdTableSort.tableId = tbl.id;
                                fdTableSort.prepareTableData(tbl);
                                if(fdTableSort.tableCache[tbl.id].rowStyle) {
                                        fdTableSort.redraw(tbl.id, false);
                                };
                        };
                };
                
                fdTableSort.thNode = null;
                aclone = a = span = onLoadSort = columnNumSortObj = thNode = tbl = allRowArr = rowArr = null;
        },
        initWrapper: function(e) {
                e = e || window.event;
                var kc = e.type == "keydown" ? e.keyCode != null ? e.keyCode : e.charCode : -1;

                if(fdTableSort.thNode == null && (e.type == "click" || kc == 13)) {
                        var targ = this;
                        while(targ.tagName.toLowerCase() != "th") { targ = targ.parentNode; };
                        fdTableSort.thNode = targ;
                        while(targ.tagName.toLowerCase() != "table") { targ = targ.parentNode; };
                        fdTableSort.tableId = targ.id;

                        fdTableSort.multi = e.shiftKey;
                        setTimeout(fdTableSort.initSort,5,false);
                        return fdTableSort.stopEvent(e);
                };
                return kc != -1 ? true : fdTableSort.stopEvent(e);
        },
        jsWrapper: function(tableid, colNums) {
                if(!(colNums instanceof Array)) { colNums = [colNums]; };
                if(!(tableid in fdTableSort.tmpCache)) { return false; };
                if(!(tableid in fdTableSort.tableCache)) { fdTableSort.prepareTableData(document.getElementById(tableid)); };

                fdTableSort.tableId = tableid;
                var len = colNums.length, colNum;

                if(fdTableSort.tableCache[tableid].thList.length == colNums.length) {
                        var identical = true;
                        var th;
                        for(var i = 0; i < len; i++) {
                                colNum = colNums[i];
                                th = fdTableSort.tmpCache[tableid].headers[0][colNum];
                                if(th != fdTableSort.tableCache[tableid].thList[i]) {
                                        identical = false;
                                        break;
                                };
                        };
                        if(identical) {
                                fdTableSort.thNode = th;
                                fdTableSort.initSort(true);
                                return;
                        };
                };

                for(var i = 0; i < len; i++) {
                        fdTableSort.multi = i;
                        colNum = colNums[i];
                        fdTableSort.thNode = fdTableSort.tmpCache[tableid].headers[0][colNum];
                        fdTableSort.initSort(true);
                };
        },

        addSortActiveClass: function() {
                if(fdTableSort.thNode == null) { return; };
                fdTableSort.addClass(fdTableSort.thNode, "sort-active");
                fdTableSort.addClass(document.getElementsByTagName('body')[0], "sort-active");
                if(!fdTableSort.tableId || !(fdTableSort.tableId in fdTableSort.tableCache)) { return; };
                fdTableSort.callback(fdTableSort.tableId, fdTableSort.tableCache[fdTableSort.tableId].initiatedCallback);
        },

        removeSortActiveClass: function() {
                if(fdTableSort.thNode == null) return;
                fdTableSort.removeClass(fdTableSort.thNode, "sort-active");
                fdTableSort.removeClass(document.getElementsByTagName('body')[0], "sort-active");
                if(!fdTableSort.tableId || !(fdTableSort.tableId in fdTableSort.tableCache)) { return; };
                fdTableSort.callback(fdTableSort.tableId, fdTableSort.tableCache[fdTableSort.tableId].completeCallback);
        },

        addClass: function(e,c) {
                if(new RegExp("(^|\\s)" + c + "(\\s|$)").test(e.className)) return;
                e.className += ( e.className ? " " : "" ) + c;
        },

        /*@cc_on
        /*@if (@_win32)
        removeClass: function(e,c) {
                e.className = !c ? "" : e.className.replace(new RegExp("(^|\\s)" + c + "(\\s|$)"), " ").replace(/^\s*((?:[\S\s]*\S)?)\s*$/, '$1');
        },
        @else @*/
        removeClass: function(e,c) {
                e.className = !c ? "" : e.className.replace(new RegExp("(^|\\s)" + c + "(\\s|$)"), " ").replace(/^\s\s*/, '').replace(/\s\s*$/, '');
        },
        /*@end
        @*/

        callback: function(tblId, cb) {
                var func;
                if(cb.indexOf(".") != -1) {
                        var split = cb.split(".");
                        func = window;
                        for(var i = 0, f; f = split[i]; i++) {
                                if(f in func) {
                                        func = func[f];
                                } else {
                                        func = "";
                                        break;
                                };
                        };
                } else if(cb + tblId in window) {
                        func = window[cb + tblId];
                } else if(cb in window) {
                        func = window[cb];
                };
                if(typeof func == "function") { func(tblId); };
                func = null;
        },
        
        prepareTableData: function(table) {
                var data = [];

                var start = table.getElementsByTagName('tbody');
                start = start.length ? start[0] : table;

                var trs = start.rows;
                var ths = table.getElementsByTagName('th');

                var numberOfRows = trs.length;
                var numberOfCols = fdTableSort.tmpCache[table.id].cols;

                var data = [];
                var identical = new Array(numberOfCols);
                var identVal  = new Array(numberOfCols);

                for(var tmp = 0; tmp < numberOfCols; tmp++) identical[tmp] = true;

                var tr, td, th, txt, tds, col, row;

                var re = new RegExp(/fd-column-([0-9]+)/);
                var rowCnt = 0;

                var sortableColumnNumbers = [];

                for(var tmp = 0, th; th = ths[tmp]; tmp++) {
                        if(th.className.search(re) == -1) continue;
                        sortableColumnNumbers[sortableColumnNumbers.length] = th;
                };

                // Start to create the 2D matrix of data
                for(row = 0; row < numberOfRows; row++) {

                        tr              = trs[row];

                        if(tr.parentNode != start || tr.getElementsByTagName("th").length || (tr.parentNode && tr.parentNode.tagName.toLowerCase().search(/thead|tfoot/) != -1)) continue;

                        data[rowCnt]    = [];
                        tds             = tr.cells;

                        for(var tmp = 0, th; th = sortableColumnNumbers[tmp]; tmp++) {
                                col = th.className.match(re)[1];

                                td  = tds[col];

                                txt = fdTableSort.getInnerText(td) + " ";

                                txt = txt.replace(/^\s+/,'').replace(/\s+$/,'');

                                if(th.className.search(/sortable-date/) != -1) {
                                        txt = fdTableSort.dateFormat(txt, th.className.search(/sortable-date-dmy/) != -1);
                                } else if(th.className.search(/sortable-numeric|sortable-currency/) != -1) {
                                        txt = parseFloat(txt.replace(/[^0-9\.\-]/g,''));
                                        if(isNaN(txt)) txt = "";
                                } else if(th.className.search(/sortable-text/) != -1) {
                                        txt = txt.toLowerCase();
                                } else if (th.className.search(/sortable-keep/) != -1) {
                                        txt = rowCnt;
                                } else if(th.className.search(/sortable-([a-zA-Z\_]+)/) != -1) {
                                        if((th.className.match(/sortable-([a-zA-Z\_]+)/)[1] + "PrepareData") in window) {
                                                txt = window[th.className.match(/sortable-([a-zA-Z\_]+)/)[1] + "PrepareData"](td, txt);
                                        };
                                } else if(txt != "") {
                                        fdTableSort.removeClass(th, "sortable");
                                        if(fdTableSort.dateFormat(txt) != 0) {
                                                fdTableSort.addClass(th, "sortable-date");
                                                txt = fdTableSort.dateFormat(txt);
                                        } else if(txt.search(fdTableSort.regExp_Number) != -1 || txt.search(fdTableSort.regExp_Currency) != -1) {
                                                fdTableSort.addClass(th, "sortable-numeric");
                                                txt = parseFloat(txt.replace(/[^0-9\.\-]/g,''));
                                                if(isNaN(txt)) txt = "";
                                        } else {
                                                fdTableSort.addClass(th, "sortable-text");
                                                txt = txt.toLowerCase();
                                        };
                                };

                                if(rowCnt > 0 && identical[col] && identVal[col] != txt) {
                                        identical[col] = false;
                                };

                                identVal[col]     = txt;
                                data[rowCnt][col] = txt;
                        };

                        // Add the tr for this row
                        data[rowCnt][numberOfCols] = tr;

                        // Increment the row count
                        rowCnt++;
                }

                // Get the row and column styles
                var colStyle = table.className.search(/colstyle-([\S]+)/) != -1 ? table.className.match(/colstyle-([\S]+)/)[1] : false;
                var rowStyle = table.className.search(/rowstyle-([\S]+)/) != -1 ? table.className.match(/rowstyle-([\S]+)/)[1] : false;
                var iCBack   = table.className.search(/sortinitiatedcallback-([\S-]+)/) == -1 ? "sortInitiatedCallback" : table.className.match(/sortinitiatedcallback-([\S]+)/)[1];
                var cCBack   = table.className.search(/sortcompletecallback-([\S-]+)/) == -1 ? "sortCompleteCallback" : table.className.match(/sortcompletecallback-([\S]+)/)[1];

                // Replace "-" with "." to enable Object.method callbacks
                iCBack = iCBack.replace("-", ".");
                cCBack = cCBack.replace("-", ".");

                // Cache the data object for this table
                fdTableSort.tableCache[table.id] = { hook:start, initiatedCallback:iCBack, completeCallback:cCBack, thList:[], colOrder:{}, data:data, identical:identical, colStyle:colStyle, rowStyle:rowStyle, noArrow:table.className.search(/no-arrow/) != -1 };

                sortableColumnNumbers = data = tr = td = th = trs = identical = identVal = null;
        },

        onUnload: function() {
                for(tbl in fdTableSort.tableCache) {
                        fdTableSort.removeTableCache(tbl);
                };
                for(tbl in fdTableSort.tmpCache) {
                        fdTableSort.removeTmpCache(tbl);
                };
                fdTableSort.removeEvent(window, "load", fdTableSort.initEvt);
                fdTableSort.removeEvent(window, "unload", fdTableSort.onUnload);
                fdTableSort.tmpCache = fdTableSort.tableCache = null;
        },

        addThNode: function() {
                var dataObj = fdTableSort.tableCache[fdTableSort.tableId];
                var pos     = fdTableSort.thNode.className.match(/fd-column-([0-9]+)/)[1];
                var alt     = false;

                dataObj.colOrder = {};

                if(!fdTableSort.multi) {
                        if(dataObj.colStyle) {
                                var len = dataObj.thList.length;
                                for(var i = 0; i < len; i++) {
                                        dataObj.colOrder[dataObj.thList[i].className.match(/fd-column-([0-9]+)/)[1]] = false;
                                };
                        };
                        if(dataObj.thList.length && dataObj.thList[0] == fdTableSort.thNode) alt = true;
                        dataObj.thList = [];
                };

                var found = false;
                var l = dataObj.thList.length;

                for(var i = 0, n; n = dataObj.thList[i]; i++) {
                        if(n == fdTableSort.thNode) {
                                found = true;
                                break;
                        };
                };

                if(!found) {
                        dataObj.thList.push(fdTableSort.thNode);
                        if(dataObj.colStyle) { dataObj.colOrder[pos] = true; };
                };

                var ths = document.getElementById(fdTableSort.tableId).getElementsByTagName("th");
                for(var i = 0, th; th = ths[i]; i++) {
                        found = false;
                        for(var z = 0, n; n = dataObj.thList[z]; z++) {
                                if(n == th) {
                                        found = true;
                                        break;
                                };
                        };
                        if(!found) {
                                fdTableSort.removeClass(th, "(forwardSort|reverseSort)");
                                if(!dataObj.noArrow) {
                                        span = th.getElementsByTagName('span');
                                        if(span.length) {
                                                span = span[0];
                                                while(span.firstChild) span.removeChild(span.firstChild);
                                        };
                                };
                        };
                };

                if(dataObj.thList.length > 1) {
                        classToAdd = fdTableSort.thNode.className.search(/forwardSort/) != -1 ? "reverseSort" : "forwardSort";
                        fdTableSort.removeClass(fdTableSort.thNode, "(forwardSort|reverseSort)");
                        fdTableSort.addClass(fdTableSort.thNode, classToAdd);
                        dataObj.pos = -1
                } else if(alt) { dataObj.pos = fdTableSort.thNode };
        },

        initSort: function(noCallback) {
                var thNode      = fdTableSort.thNode;
                var tableElem   = document.getElementById(fdTableSort.tableId);

                if(!(fdTableSort.tableId in fdTableSort.tableCache)) { fdTableSort.prepareTableData(document.getElementById(fdTableSort.tableId)); };
                
                fdTableSort.addThNode();

                if(!noCallback) { fdTableSort.addSortActiveClass(); };
                
                // Get the column position using the className added earlier
                fdTableSort.pos = thNode.className.match(/fd-column-([0-9]+)/)[1];

                // Grab the data object for this table
                var dataObj     = fdTableSort.tableCache[tableElem.id];

                // Get the position of the last column that was sorted
                var lastPos     = dataObj.pos && dataObj.pos.className ? dataObj.pos.className.match(/fd-column-([0-9]+)/)[1] : -1;

                // Get the stored data object for this table
                var len1        = dataObj.data.length;
                var len2        = dataObj.data.length > 0 ? dataObj.data[0].length - 1 : 0;
                var identical   = dataObj.identical[fdTableSort.pos];

                // If the same column is being sorted then just reverse the data object contents.
                var classToAdd = "forwardSort";

                if(dataObj.thList.length > 1) {
                        // Multi sort

                        var js  = "var sortWrapper = function(a,b) {\n";
                        var l   = dataObj.thList.length;
                        var cnt = 0;
                        var e,d,th,p,f;

                        for(var i=0; i < l; i++) {
                                th = dataObj.thList[i];
                                p  = th.className.match(/fd-column-([0-9]+)/)[1];
                                if(dataObj.identical[p]) { continue; };
                                cnt++;

                                if(th.className.match(/sortable-(numeric|currency|date|keep)/)) {
                                        f = "fdTableSort.sortNumeric";
                                } else if(th.className.match('sortable-text')) {
                                        f = "fdTableSort.sortText";
                                } else if(th.className.search(/sortable-([a-zA-Z\_]+)/) != -1 && th.className.match(/sortable-([a-zA-Z\_]+)/)[1] in window) {
                                        f = "window['" + th.className.match(/sortable-([a-zA-Z\_]+)/)[1] + "']";
                                } else  f = "fdTableSort.sortText";

                                e = "e" + i;
                                d = th.className.search('forwardSort') != -1 ? "a,b" : "b,a";
                                js += "fdTableSort.pos   = " + p + ";\n";
                                js += "var " + e + " = "+f+"(" + d +");\n";
                                js += "if(" + e + ") return " + e + ";\n";
                                js += "else { \n";
                        };

                        js += "return 0;\n";

                        for(var i=0; i < cnt; i++) {
                                js += "};\n";
                        };

                        if(cnt) js += "return 0;\n";
                        js += "};\n";

                        eval(js);
                        dataObj.data.sort(sortWrapper);
                        identical = false;
                } else if((lastPos == fdTableSort.pos && !identical) || (thNode.className.search(/sortable-keep/) != -1 && lastPos == -1)) {
                        dataObj.data.reverse();
                        classToAdd = thNode.className.search(/reverseSort/) != -1 ? "forwardSort" : "reverseSort";
                        if(thNode.className.search(/sortable-keep/) != -1 && lastPos == -1) fdTableSort.tableCache[tableElem.id].pos = thNode;
                } else {
                        fdTableSort.tableCache[tableElem.id].pos = thNode;
                        classToAdd = thNode.className.search(/forwardSort/) != -1 ? "reverseSort" : "forwardSort";
                        if(!identical) {
                                if(thNode.className.match(/sortable-(numeric|currency|date|keep)/)) {
                                        dataObj.data.sort(fdTableSort.sortNumeric);
                                } else if(thNode.className.match('sortable-text')) {
                                        dataObj.data.sort(fdTableSort.sortText);
                                } else if(thNode.className.search(/sortable-([a-zA-Z\_]+)/) != -1 && thNode.className.match(/sortable-([a-zA-Z\_]+)/)[1] in window) {
                                        dataObj.data.sort(window[thNode.className.match(/sortable-([a-zA-Z\_]+)/)[1]]);
                                };
                        };
                };

                if(dataObj.thList.length == 1) {
                        fdTableSort.removeClass(thNode, "(forwardSort|reverseSort)");
                        fdTableSort.addClass(thNode, classToAdd);
                };

                if(!dataObj.noArrow) {
                        var span = fdTableSort.thNode.getElementsByTagName('span')[0];
                        if(span.firstChild) span.removeChild(span.firstChild);
                        span.appendChild(document.createTextNode(fdTableSort.thNode.className.search(/forwardSort/) != -1 ? " \u2193" : " \u2191"));
                };

                if(!dataObj.rowStyle && !dataObj.colStyle && identical) {
                        if(!noCallback) fdTableSort.removeSortActiveClass();
                        fdTableSort.thNode = null;
                        return;
                };

                if("tablePaginater" in window && "tableInfo" in tablePaginater && fdTableSort.tableId in tablePaginater.tableInfo) {
                        tablePaginater.redraw(fdTableSort.tableId, identical);
                } else {
                        fdTableSort.redraw(fdTableSort.tableId, identical);
                };
                
                if(!noCallback) { fdTableSort.removeSortActiveClass(); };
                fdTableSort.thNode = null;

                // this resets the alternating colors after sort
                setAlternatingTrs();
        },

        redraw: function(tableid, identical) {
                if(!tableid || !(tableid in fdTableSort.tableCache)) { return; };
                var dataObj     = fdTableSort.tableCache[tableid];
                var data        = dataObj.data;
                var len1        = data.length;
                var len2        = len1 ? data[0].length - 1 : 0;
                var hook        = dataObj.hook;
                var colStyle    = dataObj.colStyle;
                var rowStyle    = dataObj.rowStyle;
                var colOrder    = dataObj.colOrder;
                var highLight   = 0;
                var reg         = /(^|\s)invisibleRow(\s|$)/;
                var tr, tds;

                for(var i = 0; i < len1; i++) {
                        tr = data[i][len2];
                        if(colStyle) {
                                tds = tr.cells;
                                for(thPos in colOrder) {
                                        if(!colOrder[thPos]) fdTableSort.removeClass(tds[thPos], colStyle);
                                        else fdTableSort.addClass(tds[thPos], colStyle);
                                };
                        };
                        if(!identical) {
                                if(rowStyle && tr.className.search(reg) == -1) {
                                        if(highLight++ & 1) fdTableSort.addClass(tr, rowStyle);
                                        else fdTableSort.removeClass(tr, rowStyle);
                                };

                                // Netscape 8.1.2 requires the removeChild call or it freaks out, so add the line if you want to support this browser
                                // hook.removeChild(tr);
                                hook.appendChild(tr);
                        };
                };
                
                tr = tds = hook = null;
        },

        getInnerText: function(el) {
                if (typeof el == "string" || typeof el == "undefined") return el;
                if(el.innerText) return el.innerText;
                var txt = '', i;
                for(i = el.firstChild; i; i = i.nextSibling) {
                        if(i.nodeType == 3)            txt += i.nodeValue;
                        else if(i.nodeType == 1)       txt += fdTableSort.getInnerText(i);
                };
                return txt;
        },

        dateFormat: function(dateIn, favourDMY) {
                var dateTest = [
                        { regExp:/^(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])([- \/.])((\d\d)?\d\d)$/, d:3, m:1, y:5 },  // mdy
                        { regExp:/^(0?[1-9]|[12][0-9]|3[01])([- \/.])(0?[1-9]|1[012])([- \/.])((\d\d)?\d\d)$/, d:1, m:3, y:5 },  // dmy
                        { regExp:/^(\d\d\d\d)([- \/.])(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])$/, d:5, m:3, y:1 }      // ymd
                        ];
                var start;
                var cnt = 0;
                var numFormats = dateTest.length;
                while(cnt < numFormats) {
                        start = (cnt + (favourDMY ? numFormats + 1 : numFormats)) % numFormats;
                        if(dateIn.match(dateTest[start].regExp)) {
                                res = dateIn.match(dateTest[start].regExp);
                                y = res[dateTest[start].y];
                                m = res[dateTest[start].m];
                                d = res[dateTest[start].d];
                                if(m.length == 1) m = "0" + String(m);
                                if(d.length == 1) d = "0" + String(d);
                                if(y.length != 4) y = (parseInt(y) < 50) ? "20" + String(y) : "19" + String(y);

                                return y+String(m)+d;
                        };
                        cnt++;
                };
                return 0;
        },

        sortNumeric:function(a,b) {
                var aa = a[fdTableSort.pos];
                var bb = b[fdTableSort.pos];
                if(aa == bb) return 0;
                if(aa === "" && !isNaN(bb)) return -1;
                if(bb === "" && !isNaN(aa)) return 1;
                return aa - bb;
        },

        sortText:function(a,b) {
                var aa = a[fdTableSort.pos];
                var bb = b[fdTableSort.pos];
                if(aa == bb) return 0;
                if(aa < bb)  return -1;
                return 1;
        }

};

})();

fdTableSort.addEvent(window, "load",   fdTableSort.initEvt);
fdTableSort.addEvent(window, "unload", fdTableSort.onUnload);



// variable_info.js

function count(variable)
{
	var i=0;
	if(typeof(variable) == 'object' && variable !== null)
	{
		if(typeof(variable.nodeName) != 'undefined') 
			return variable.length;

		foreach(variable, function() 
			{ i++; }
		);
	}
	else if(!empty(variable))
		i = 1;

	return i;
}

function empty(variable) 
{
	if(typeof(variable) == 'undefined')
		return 'Not set';

	if(typeof(variable) == 'object' && variable !== null)
	{
		//if DOM list
		if(array_key_exists(variable, 'nodeName'))
		{
			if(!variable.firstChild && empty(variable.nodeValue))
				return true;
			return false;
		}

		return !(Boolean(count(variable)));
	}    
	
	if(typeof(variable) == 'string')
		variable = trim(variable);

	return (variable == null || variable === '' || Number(variable) === 0 || variable === false); 
}

function isEmpty(variable)
{
	if(typeof variable != 'object')
		return empty(variable);
		
	var is_empty = true;
	foreach(variable, function(value)
	{
		if(!isEmpty(value))
		{
			is_empty = false;
			return; //break
		}
	});
	
	return is_empty;
}

function rdump(variable, display_full, stack_counter)
{
	if(variable === null)
		return 'NULL';
		
	var display_full = display_full || false;
	var stack_counter = stack_counter || 0;
	var string = '';

	if(typeof(variable) == 'object' && variable !== null)
	{
		string = (stack_counter == 0) ? typeof(variable) + "\n{\n" : '';

		var dom = (typeof(variable.nodeName) != 'undefined');

		if(dom)
		{
			for(i in variable)
				if(i != 'selectionStart' && i != 'selectionEnd' && i != 'boxObject')
					string += '[' + i + '] => ' + (display_full ? '(' + typeof(variable[i]) + ') ' : '') + variable[i] + "\n";
		}
		else
		{
			foreach(variable, function(value, key)
			{
				var i;
				var tabs = '';
				for(i=0; i<=stack_counter + 1; i++)
					tabs += "\t";
	
				string += tabs;
		
				if((typeof(value) == 'object'))
					string += '[' + key + '] => ' + (display_full ? typeof(value) + ' (' + value.length + ')' : '') + "\n " + tabs + "{\n" + rdump(value, display_full, (Number(stack_counter) + 1)) + tabs + "}\n";
				else
					string += '[' + key + '] => ' + (display_full ? '(' + typeof(value) + ') ' : '') + value + "\n";
			});
		}

		if(stack_counter == 0)
			string += '}';
	}
	else
    	string += '(' + typeof(variable) + ') ' + variable + "\n";

	return string;
}

function dump(variable, return_dump, display_full)
{
	var display_full = display_full || false;
	var return_dump = return_dump || false;

	if(return_dump)
		return rdump(variable, display_full);
	else
		echo('<pre>' + rdump(variable, display_full) + '</pre>');
}

function die(error_message)
{
	if(typeof(error_message) == 'string')
		alert(error_message);

	alert(IntentionalDie);
}

function invalidFunctionCall(function_arguments)
{
	var required_arguments = arguments;

	var i;
	var string = 'Invalid function call to function ' + function_arguments.callee.name + "()\n\n"
+"Required Arguments: \n";

	for(i=1; i< required_arguments.length; i++)
		string += '\targs[' + (i-1) + '] = ' + required_arguments[i] + "\n";

	string += "\nPassed Arguments: \n";

	for(i=0; i< function_arguments.length; i++)
		string += '\targs[' + i + '] = ' + function_arguments[i] + "\n";

	return string;
}

function getKey(e) 
{
	var ascii_code;
	if (!e) var e = window.event;
	if (e.keyCode) ascii_code = e.keyCode;
	else if (e.which) ascii_code = e.which;
	return ascii_code;
}/*  Prototype JavaScript framework, version 1.6.0.2
 *  (c) 2005-2008 Sam Stephenson
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.6.0.2',

  Browser: {
    IE:     !!(window.attachEvent && !window.opera),
    Opera:  !!window.opera,
    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,
    MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
  },

  BrowserFeatures: {
    XPath: !!document.evaluate,
    ElementExtensions: !!window.HTMLElement,
    SpecificElementExtensions:
      document.createElement('div').__proto__ &&
      document.createElement('div').__proto__ !==
        document.createElement('form').__proto__
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },
  K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
  Prototype.BrowserFeatures.SpecificElementExtensions = false;


/* Based on Alex Arnell's inheritance implementation. */
var Class = {
  create: function() {
    var parent = null, properties = $A(arguments);
    if (Object.isFunction(properties[0]))
      parent = properties.shift();

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      var subclass = function() { };
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

    for (var i = 0; i < properties.length; i++)
      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;

    return klass;
  }
};

Class.Methods = {
  addMethods: function(source) {
    var ancestor   = this.superclass && this.superclass.prototype;
    var properties = Object.keys(source);

    if (!Object.keys({ toString: true }).length)
      properties.push("toString", "valueOf");

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames().first() == "$super") {
        var method = value, value = Object.extend((function(m) {
          return function() { return ancestor[m].apply(this, arguments) };
        })(property).wrap(method), {
          valueOf:  function() { return method },
          toString: function() { return method.toString() }
        });
      }
      this.prototype[property] = value;
    }

    return this;
  }
};

var Abstract = { };

Object.extend = function(destination, source) {
  for (var property in source)
    destination[property] = source[property];
  return destination;
};

Object.extend(Object, {
  inspect: function(object) {
    try {
      if (Object.isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },

  toJSON: function(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (Object.isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (!Object.isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  },

  toQueryString: function(object) {
    return $H(object).toQueryString();
  },

  toHTML: function(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  },

  keys: function(object) {
    var keys = [];
    for (var property in object)
      keys.push(property);
    return keys;
  },

  values: function(object) {
    var values = [];
    for (var property in object)
      values.push(object[property]);
    return values;
  },

  clone: function(object) {
    return Object.extend({ }, object);
  },

  isElement: function(object) {
    return object && object.nodeType == 1;
  },

  isArray: function(object) {
    return object != null && typeof object == "object" &&
      'splice' in object && 'join' in object;
  },

  isHash: function(object) {
    return object instanceof Hash;
  },

  isFunction: function(object) {
    return typeof object == "function";
  },

  isString: function(object) {
    return typeof object == "string";
  },

  isNumber: function(object) {
    return typeof object == "number";
  },

  isUndefined: function(object) {
    return typeof object == "undefined";
  }
});

Object.extend(Function.prototype, {
  argumentNames: function() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",").invoke("strip");
    return names.length == 1 && !names[0] ? [] : names;
  },

  bind: function() {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = $A(arguments), object = args.shift();
    return function() {
      return __method.apply(object, args.concat($A(arguments)));
    }
  },

  bindAsEventListener: function() {
    var __method = this, args = $A(arguments), object = args.shift();
    return function(event) {
      return __method.apply(object, [event || window.event].concat(args));
    }
  },

  curry: function() {
    if (!arguments.length) return this;
    var __method = this, args = $A(arguments);
    return function() {
      return __method.apply(this, args.concat($A(arguments)));
    }
  },

  delay: function() {
    var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  },

  wrap: function(wrapper) {
    var __method = this;
    return function() {
      return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
    }
  },

  methodize: function() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      return __method.apply(null, [this].concat($A(arguments)));
    };
  }
});

Function.prototype.defer = Function.prototype.delay.curry(0.01);

Date.prototype.toJSON = function() {
  return '"' + this.getUTCFullYear() + '-' +
    (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
    this.getUTCDate().toPaddedString(2) + 'T' +
    this.getUTCHours().toPaddedString(2) + ':' +
    this.getUTCMinutes().toPaddedString(2) + ':' +
    this.getUTCSeconds().toPaddedString(2) + 'Z"';
};

var Try = {
  these: function() {
    var returnValue;

    for (var i = 0, length = arguments.length; i < length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) { }
    }

    return returnValue;
  }
};

RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create({
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

  registerCallback: function() {
    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  execute: function() {
    this.callback(this);
  },

  stop: function() {
    if (!this.timer) return;
    clearInterval(this.timer);
    this.timer = null;
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.execute();
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
});
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

Object.extend(String.prototype, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(replacement);

    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += String.interpret(replacement(match));
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  },

  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = Object.isUndefined(count) ? 1 : count;

    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  },

  scan: function(pattern, iterator) {
    this.gsub(pattern, iterator);
    return String(this);
  },

  truncate: function(length, truncation) {
    length = length || 30;
    truncation = Object.isUndefined(truncation) ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : String(this);
  },

  strip: function() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  },

  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },

  stripScripts: function() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  },

  extractScripts: function() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  },

  evalScripts: function() {
    return this.extractScripts().map(function(script) { return eval(script) });
  },

  escapeHTML: function() {
    var self = arguments.callee;
    self.text.data = this;
    return self.div.innerHTML;
  },

  unescapeHTML: function() {
    var div = new Element('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  },

  toQueryParams: function(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  },

  toArray: function() {
    return this.split('');
  },

  succ: function() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  },

  times: function(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  },

  camelize: function() {
    var parts = this.split('-'), len = parts.length;
    if (len == 1) return parts[0];

    var camelized = this.charAt(0) == '-'
      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
      : parts[0];

    for (var i = 1; i < len; i++)
      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

    return camelized;
  },

  capitalize: function() {
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  },

  underscore: function() {
    return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
  },

  dasherize: function() {
    return this.gsub(/_/,'-');
  },

  inspect: function(useDoubleQuotes) {
    var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
      var character = String.specialChar[match[0]];
      return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  },

  toJSON: function() {
    return this.inspect(true);
  },

  unfilterJSON: function(filter) {
    return this.sub(filter || Prototype.JSONFilter, '#{1}');
  },

  isJSON: function() {
    var str = this;
    if (str.blank()) return false;
    str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
  },

  evalJSON: function(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  },

  include: function(pattern) {
    return this.indexOf(pattern) > -1;
  },

  startsWith: function(pattern) {
    return this.indexOf(pattern) === 0;
  },

  endsWith: function(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  },

  empty: function() {
    return this == '';
  },

  blank: function() {
    return /^\s*$/.test(this);
  },

  interpolate: function(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }
});

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
  escapeHTML: function() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  },
  unescapeHTML: function() {
    return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
  }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
  if (Object.isFunction(replacement)) return replacement;
  var template = new Template(replacement);
  return function(match) { return template.evaluate(match) };
};

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
  div:  document.createElement('div'),
  text: document.createTextNode('')
});

with (String.prototype.escapeHTML) div.appendChild(text);

var Template = Class.create({
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    if (Object.isFunction(object.toTemplateReplacements))
      object = object.toTemplateReplacements();

    return this.template.gsub(this.pattern, function(match) {
      if (object == null) return '';

      var before = match[1] || '';
      if (before == '\\') return match[2];

      var ctx = object, expr = match[3];
      var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
      match = pattern.exec(expr);
      if (match == null) return before;

      while (match != null) {
        var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
        ctx = ctx[comp];
        if (null == ctx || '' == match[3]) break;
        expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
        match = pattern.exec(expr);
      }

      return before + String.interpret(ctx);
    });
  }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = {
  each: function(iterator, context) {
    var index = 0;
    iterator = iterator.bind(context);
    try {
      this._each(function(value) {
        iterator(value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  },

  eachSlice: function(number, iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var index = -number, slices = [], array = this.toArray();
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);
  },

  all: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var result = true;
    this.each(function(value, index) {
      result = result && !!iterator(value, index);
      if (!result) throw $break;
    });
    return result;
  },

  any: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var result = false;
    this.each(function(value, index) {
      if (result = !!iterator(value, index))
        throw $break;
    });
    return result;
  },

  collect: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var results = [];
    this.each(function(value, index) {
      results.push(iterator(value, index));
    });
    return results;
  },

  detect: function(iterator, context) {
    iterator = iterator.bind(context);
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },

  findAll: function(iterator, context) {
    iterator = iterator.bind(context);
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },

  grep: function(filter, iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(filter);

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator(value, index));
    });
    return results;
  },

  include: function(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },

  inGroupsOf: function(number, fillWith) {
    fillWith = Object.isUndefined(fillWith) ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  },

  inject: function(memo, iterator, context) {
    iterator = iterator.bind(context);
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },

  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  },

  max: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator(value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  },

  min: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator(value, index);
      if (result == null || value < result)
        result = value;
    });
    return result;
  },

  partition: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : Prototype.K;
    var trues = [], falses = [];
    this.each(function(value, index) {
      (iterator(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },

  pluck: function(property) {
    var results = [];
    this.each(function(value) {
      results.push(value[property]);
    });
    return results;
  },

  reject: function(iterator, context) {
    iterator = iterator.bind(context);
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },

  sortBy: function(iterator, context) {
    iterator = iterator.bind(context);
    return this.map(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },

  toArray: function() {
    return this.map();
  },

  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (Object.isFunction(args.last()))
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  },

  size: function() {
    return this.toArray().length;
  },

  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
};

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  filter:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray,
  every:   Enumerable.all,
  some:    Enumerable.any
});
function $A(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

if (Prototype.Browser.WebKit) {
  $A = function(iterable) {
    if (!iterable) return [];
    if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&
        iterable.toArray) return iterable.toArray();
    var length = iterable.length || 0, results = new Array(length);
    while (length--) results[length] = iterable[length];
    return results;
  };
}

Array.from = $A;

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  },

  clear: function() {
    this.length = 0;
    return this;
  },

  first: function() {
    return this[0];
  },

  last: function() {
    return this[this.length - 1];
  },

  compact: function() {
    return this.select(function(value) {
      return value != null;
    });
  },

  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(Object.isArray(value) ?
        value.flatten() : [value]);
    });
  },

  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },

  reduce: function() {
    return this.length > 1 ? this : this[0];
  },

  uniq: function(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  },

  intersect: function(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  },

  clone: function() {
    return [].concat(this);
  },

  size: function() {
    return this.length;
  },

  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  },

  toJSON: function() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (!Object.isUndefined(value)) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }
});

// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
  Array.prototype._each = Array.prototype.forEach;

if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
  i || (i = 0);
  var length = this.length;
  if (i < 0) i = length + i;
  for (; i < length; i++)
    if (this[i] === item) return i;
  return -1;
};

if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
  i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
  var n = this.slice(0, i).reverse().indexOf(item);
  return (n < 0) ? n : i - n - 1;
};

Array.prototype.toArray = Array.prototype.clone;

function $w(string) {
  if (!Object.isString(string)) return [];
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}

if (Prototype.Browser.Opera){
  Array.prototype.concat = function() {
    var array = [];
    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for (var i = 0, length = arguments.length; i < length; i++) {
      if (Object.isArray(arguments[i])) {
        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  };
}
Object.extend(Number.prototype, {
  toColorPart: function() {
    return this.toPaddedString(2, 16);
  },

  succ: function() {
    return this + 1;
  },

  times: function(iterator) {
    $R(0, this, true).each(iterator);
    return this;
  },

  toPaddedString: function(length, radix) {
    var string = this.toString(radix || 10);
    return '0'.times(length - string.length) + string;
  },

  toJSON: function() {
    return isFinite(this) ? this.toString() : 'null';
  }
});

$w('abs round ceil floor').each(function(method){
  Number.prototype[method] = Math[method].methodize();
});
function $H(object) {
  return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {

  function toQueryPair(key, value) {
    if (Object.isUndefined(value)) return key;
    return key + '=' + encodeURIComponent(String.interpret(value));
  }

  return {
    initialize: function(object) {
      this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
    },

    _each: function(iterator) {
      for (var key in this._object) {
        var value = this._object[key], pair = [key, value];
        pair.key = key;
        pair.value = value;
        iterator(pair);
      }
    },

    set: function(key, value) {
      return this._object[key] = value;
    },

    get: function(key) {
      return this._object[key];
    },

    unset: function(key) {
      var value = this._object[key];
      delete this._object[key];
      return value;
    },

    toObject: function() {
      return Object.clone(this._object);
    },

    keys: function() {
      return this.pluck('key');
    },

    values: function() {
      return this.pluck('value');
    },

    index: function(value) {
      var match = this.detect(function(pair) {
        return pair.value === value;
      });
      return match && match.key;
    },

    merge: function(object) {
      return this.clone().update(object);
    },

    update: function(object) {
      return new Hash(object).inject(this, function(result, pair) {
        result.set(pair.key, pair.value);
        return result;
      });
    },

    toQueryString: function() {
      return this.map(function(pair) {
        var key = encodeURIComponent(pair.key), values = pair.value;

        if (values && typeof values == 'object') {
          if (Object.isArray(values))
            return values.map(toQueryPair.curry(key)).join('&');
        }
        return toQueryPair(key, values);
      }).join('&');
    },

    inspect: function() {
      return '#<Hash:{' + this.map(function(pair) {
        return pair.map(Object.inspect).join(': ');
      }).join(', ') + '}>';
    },

    toJSON: function() {
      return Object.toJSON(this.toObject());
    },

    clone: function() {
      return new Hash(this);
    }
  }
})());

Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
Hash.from = $H;
var ObjectRange = Class.create(Enumerable, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },

  _each: function(iterator) {
    var value = this.start;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  },

  include: function(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }
});

var $R = function(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
};

var Ajax = {
  getTransport: function() {
    return Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  },

  activeRequestCount: 0
};

Ajax.Responders = {
  responders: [],

  _each: function(iterator) {
    this.responders._each(iterator);
  },

  register: function(responder) {
    if (!this.include(responder))
      this.responders.push(responder);
  },

  unregister: function(responder) {
    this.responders = this.responders.without(responder);
  },

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (Object.isFunction(responder[callback])) {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) { }
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate:   function() { Ajax.activeRequestCount++ },
  onComplete: function() { Ajax.activeRequestCount-- }
});

Ajax.Base = Class.create({
  initialize: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   '',
      evalJSON:     true,
      evalJS:       true
    };
    Object.extend(this.options, options || { });

    this.options.method = this.options.method.toLowerCase();

    if (Object.isString(this.options.parameters))
      this.options.parameters = this.options.parameters.toQueryParams();
    else if (Object.isHash(this.options.parameters))
      this.options.parameters = this.options.parameters.toObject();
  }
});

Ajax.Request = Class.create(Ajax.Base, {
  _complete: false,

  initialize: function($super, url, options) {
    $super(options);
    this.transport = Ajax.getTransport();
    this.request(url);
  },

  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = Object.clone(this.options.parameters);

    if (!['get', 'post'].include(this.method)) {
      // simulate other verbs over post
      params['_method'] = this.method;
      this.method = 'post';
    }

    this.parameters = params;

    if (params = Object.toQueryString(params)) {
      // when GET, append parameters to URL
      if (this.method == 'get')
        this.url += (this.url.include('?