/* spryvalidationselect.js - revision: spry preview release 1.4 */

// copyright (c) 2006. adobe systems incorporated.
// all rights reserved.
//
// redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * neither the name of adobe systems incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// this software is provided by the copyright holders and contributors "as is"
// and any express or implied warranties, including, but not limited to, the
// implied warranties of merchantability and fitness for a particular purpose
// are disclaimed. in no event shall the copyright owner or contributors be
// liable for any direct, indirect, incidental, special, exemplary, or
// consequential damages (including, but not limited to, procurement of
// substitute goods or services; loss of use, data, or profits; or business
// interruption) however caused and on any theory of liability, whether in
// contract, strict liability, or tort (including negligence or otherwise)
// arising in any way out of the use of this software, even if advised of the
// possibility of such damage.

var spry;
if (!spry) spry = {};
if (!spry.widget) spry.widget = {};

spry.widget.validationselect = function(element, opts)
{
	this.init(element);

	spry.widget.utils.setoptions(this, opts);

	// set validateon flags
	var validateon = ['submit'].concat(this.validateon || []);
	validateon = validateon.join(",");
	this.validateon = 0 | (validateon.indexof('submit') != -1 ? spry.widget.validationselect.onsubmit : 0);
	this.validateon = this.validateon | (validateon.indexof('blur') != -1 ? spry.widget.validationselect.onblur : 0);
	this.validateon = this.validateon | (validateon.indexof('change') != -1 ? spry.widget.validationselect.onchange : 0);


	// unfortunately in some browsers like safari, the stylesheets our
	// page depends on may not have been loaded at the time we are called.
	// this means we have to defer attaching our behaviors until after the
	// onload event fires, since some of our behaviors rely on dimensions
	// specified in the css.

	if (spry.widget.validationselect.onloaddidfire)
		this.attachbehaviors();
	else 
		spry.widget.validationselect.loadqueue.push(this);
};

spry.widget.validationselect.onchange = 1;
spry.widget.validationselect.onblur = 2;
spry.widget.validationselect.onsubmit = 4;

spry.widget.validationselect.prototype.init = function(element)
{
	this.element = this.getelement(element);
	this.selectelement = null;
	this.form = null;
	this.event_handlers = [];
	
	 // this.element can be either the container (<span>)
	 // or the <select> element, when no error messages are used.
	
	this.requiredclass = "selectrequiredstate";
	this.invalidclass = "selectinvalidstate";
	this.focusclass = "selectfocusstate";
	this.validclass = "selectvalidstate";
	
	this.emptyvalue = "";
	this.invalidvalue = null;
	this.isrequired = true;
	
	this.validateon = ["submit"];  // change, blur, submit
	// flag used to avoid cascade validation when both 
	// onchange and onblur events are used to trigger validation
	this.validatedbyonchangeevent = false;
};

spry.widget.validationselect.prototype.destroy = function() {
	for (var i=0; i<this.event_handlers.length; i++) {
		spry.widget.utils.removeeventlistener(this.event_handlers[i][0], this.event_handlers[i][1], this.event_handlers[i][2], false);
	}
	try { delete this.element; } catch(err) {}
	try { delete this.selectelement; } catch(err) {}
	try { delete this.form; } catch(err) {}
	try { delete this.event_handlers; } catch(err) {}

	var q = spry.widget.form.onsubmitwidgetqueue;
	var qlen = q.length;
	for (var i = 0; i < qlen; i++) {
		if (q[i] == this) {
			q.splice(i, 1);
			break;
		}
	}
};

spry.widget.validationselect.onloaddidfire = false;
spry.widget.validationselect.loadqueue = [];

spry.widget.validationselect.prototype.getelement = function(ele)
{
	if (ele && typeof ele == "string")
		return document.getelementbyid(ele);
	return ele;
};

spry.widget.validationselect.processloadqueue = function(handler)
{
	spry.widget.validationselect.onloaddidfire = true;
	var q = spry.widget.validationselect.loadqueue;
	var qlen = q.length;
	for (var i = 0; i < qlen; i++)
		q[i].attachbehaviors();
};

spry.widget.validationselect.addloadlistener = function(handler)
{
	if (typeof window.addeventlistener != 'undefined')
		window.addeventlistener('load', handler, false);
	else if (typeof document.addeventlistener != 'undefined')
		document.addeventlistener('load', handler, false);
	else if (typeof window.attachevent != 'undefined')
		window.attachevent('onload', handler);
};

spry.widget.validationselect.addloadlistener(spry.widget.validationselect.processloadqueue);
spry.widget.validationselect.addloadlistener(function(){
	spry.widget.utils.addeventlistener(window, "unload", spry.widget.form.destroyall, false);
});

spry.widget.validationselect.prototype.attachbehaviors = function()
{
	// find the select element inside current container
	if (this.element.nodename == "select") {
		this.selectelement = this.element;
	} else {
		this.selectelement = spry.widget.utils.getfirstchildwithnodenameatanylevel(this.element, "select");
	}

	if (this.selectelement) {
		var self = this;
		this.event_handlers = [];
		// focus
		// attach on beforeactivate instead of focus for ie 7 (to overcome this bug: setting a class name, closes the select)
		var focuseventname = "focus";
		if (navigator.useragent.tolowercase().indexof("msie 7.") != -1) {
			focuseventname = "beforeactivate";
		}
		this.event_handlers.push([this.selectelement, focuseventname, function(e) { if (self.isdisabled()) return true; return self.onfocus(e); }]);
		// blur
		this.event_handlers.push([this.selectelement, "blur", function(e) { if (self.isdisabled()) return true; return self.onblur(e); }]);
		// change
		if (this.validateon & spry.widget.validationselect.onchange) {
			this.event_handlers.push([this.selectelement, "change", function(e) { if (self.isdisabled()) return true; return self.onchange(e); }]);
			this.event_handlers.push([this.selectelement, "keypress", function(e) { if (self.isdisabled()) return true; return self.onchange(e); }]);
		}

		for (var i=0; i<this.event_handlers.length; i++) {
			spry.widget.utils.addeventlistener(this.event_handlers[i][0], this.event_handlers[i][1], this.event_handlers[i][2], false);
		}

		// submit
		this.form = spry.widget.utils.getfirstparentwithnodename(this.selectelement, "form");
		if (this.form) {
			// if no "onsubmit" handler has been attached to the current form, attach one
			if (!this.form.attachedsubmithandler && !this.form.onsubmit) {
				this.form.onsubmit = function(e) { e = e || event; return spry.widget.form.onsubmit(e, e.srcelement || e.currenttarget) };
				this.form.attachedsubmithandler = true;                 
			}
			if (!this.form.attachedresethandler) {
				spry.widget.utils.addeventlistener(this.form, "reset", function(e) { e = e || event; return spry.widget.form.onreset(e, e.srcelement || e.currenttarget) }, false);
				this.form.attachedresethandler = true;                 
			}
			// add the currrent widget to the "onsubmit" check queue;
			spry.widget.form.onsubmitwidgetqueue.push(this);
		}
	}
};


spry.widget.validationselect.prototype.addclassname = function(ele, classname)
{
	if (!ele || !classname || (ele.classname && ele.classname.search(new regexp("\\b" + classname + "\\b")) != -1))
		return;
	ele.classname += (ele.classname ? " " : "") + classname;
};

spry.widget.validationselect.prototype.removeclassname = function(ele, classname)
{
	if (!ele || !classname || (ele.classname && ele.classname.search(new regexp("\\b" + classname + "\\b")) == -1))
		return;
	ele.classname = ele.classname.replace(new regexp("\\s*\\b" + classname + "\\b", "g"), "");
};



spry.widget.validationselect.prototype.onfocus = function(e)
{
	this.hasfocus = true;
	this.validatedbyonchangeevent = false;
	this.addclassname(this.element, this.focusclass);
};

spry.widget.validationselect.prototype.onblur = function(e)
{
	this.hasfocus = false;
	var dovalidation = false;
	if (this.validateon & spry.widget.validationselect.onblur)
		dovalidation = true;
	if (dovalidation && !this.validatedbyonchangeevent)
		this.validate();
	this.removeclassname(this.element, this.focusclass);
};

spry.widget.validationselect.prototype.onchange = function(e)
{
	this.hasfocus = false;
	this.validate();
	this.validatedbyonchangeevent = true;
};

spry.widget.validationselect.prototype.reset = function() {
	this.removeclassname(this.element, this.requiredclass);
	this.removeclassname(this.element, this.invalidclass);
	this.removeclassname(this.element, this.validclass);
};

spry.widget.validationselect.prototype.validate = function() {
	this.removeclassname(this.element, this.requiredclass);
	this.removeclassname(this.element, this.invalidclass);
	this.removeclassname(this.element, this.validclass);
	// check isrequired
	if (this.isrequired) {
		// there are no options, or no option has been selected
		if (this.selectelement.options.length == 0 || this.selectelement.selectedindex == -1) {
			this.addclassname(this.element, this.requiredclass);
			return false;
		}
		// the current selected option has no "value" attribute
		// when no value is set, browsers implement different behaviour for the value property
		// ie: value = blank string ("")
		// ff, opera: value = option text
		if (this.selectelement.options[this.selectelement.selectedindex].getattribute("value") == null) {
			this.addclassname(this.element, this.requiredclass);
			return false;
		}
		// the current selected option has blank string ("") value
		if (this.selectelement.options[this.selectelement.selectedindex].value == this.emptyvalue) {
			this.addclassname(this.element, this.requiredclass);
			return false;
		}
		// the current selected option has "disabled" attribute
		// ie 6 allows to select such options
		if (this.selectelement.options[this.selectelement.selectedindex].disabled) {
			this.addclassname(this.element, this.requiredclass);
			return false;
		}
	}
	if (this.invalidvalue) {
		if (this.selectelement.options.length > 0 && 
			this.selectelement.selectedindex != -1 &&
			this.selectelement.options[this.selectelement.selectedindex].value == this.invalidvalue) {
			this.addclassname(this.element, this.invalidclass);
			return false;
		}
	}
	this.addclassname(this.element, this.validclass);
	return true;
}

spry.widget.validationselect.prototype.isdisabled = function() {
	return this.selectelement.disabled;	
}

//////////////////////////////////////////////////////////////////////
//
// spry.widget.form - common for all widgets
//
//////////////////////////////////////////////////////////////////////

if (!spry.widget.form) spry.widget.form = {};
if (!spry.widget.form.onsubmitwidgetqueue) spry.widget.form.onsubmitwidgetqueue = [];

if (!spry.widget.form.validate) {
	spry.widget.form.validate = function(vform) {
		var isvalid = true;
		var iselementvalid = true;
		var q = spry.widget.form.onsubmitwidgetqueue;
		var qlen = q.length;
		for (var i = 0; i < qlen; i++) {
			if (!q[i].isdisabled() && q[i].form == vform) {
				iselementvalid = q[i].validate();
				isvalid = iselementvalid && isvalid;
			}
		}
		return isvalid;
	}
};

if (!spry.widget.form.onsubmit) {
	spry.widget.form.onsubmit = function(e, form)
	{
		if (spry.widget.form.validate(form) == false) {
			return false;
		}
		return true;
	};
};

if (!spry.widget.form.onreset) {
	spry.widget.form.onreset = function(e, vform)
	{
		var q = spry.widget.form.onsubmitwidgetqueue;
		var qlen = q.length;
		for (var i = 0; i < qlen; i++) {
			if (!q[i].isdisabled() && q[i].form == vform && typeof(q[i].reset) == 'function') {
				q[i].reset();
			}
		}
		return true;
	};
};

if (!spry.widget.form.destroy) {
	spry.widget.form.destroy = function(form)
	{
		var q = spry.widget.form.onsubmitwidgetqueue;
		for (var i = 0; i < spry.widget.form.onsubmitwidgetqueue.length; i++) {
			if (q[i].form == form && typeof(q[i].destroy) == 'function') {
				q[i].destroy();
				i--;
			}
		}
	}
};

if (!spry.widget.form.destroyall) {
	spry.widget.form.destroyall = function()
	{
		var q = spry.widget.form.onsubmitwidgetqueue;
		for (var i = 0; i < spry.widget.form.onsubmitwidgetqueue.length; i++) {
			if (typeof(q[i].destroy) == 'function') {
				q[i].destroy();
				i--;
			}
		}
	}
};

//////////////////////////////////////////////////////////////////////
//
// spry.widget.utils
//
//////////////////////////////////////////////////////////////////////

if (!spry.widget.utils)	spry.widget.utils = {};

spry.widget.utils.setoptions = function(obj, optionsobj, ignoreundefinedprops)
{
	if (!optionsobj)
		return;
	for (var optionname in optionsobj)
	{
		if (ignoreundefinedprops && optionsobj[optionname] == undefined)
			continue;
		obj[optionname] = optionsobj[optionname];
	}
};


spry.widget.utils.getfirstchildwithnodenameatanylevel = function(node, nodename)
{
	var elements  = node.getelementsbytagname(nodename);
	if (elements) {
		return elements[0];
	}
	return null;
};

spry.widget.utils.getfirstparentwithnodename = function(node, nodename)
{
	while (node.parentnode
			&& node.parentnode.nodename.tolowercase() != nodename.tolowercase()
			&& node.parentnode.nodename != 'body') {
		node = node.parentnode;
	}

	if (node.parentnode && node.parentnode.nodename.tolowercase() == nodename.tolowercase()) {
		return node.parentnode;
	} else {
		return null;
	}
};

spry.widget.utils.destroywidgets = function (container)
{
	if (typeof container == 'string') {
		container = document.getelementbyid(container);
	}

	var q = spry.widget.form.onsubmitwidgetqueue;
	for (var i = 0; i < spry.widget.form.onsubmitwidgetqueue.length; i++) {
		if (typeof(q[i].destroy) == 'function' && spry.widget.utils.contains(container, q[i].element)) {
			q[i].destroy();
			i--;
		}
	}
};

spry.widget.utils.contains = function (who, what)
{
	if (typeof who.contains == 'object') {
		return what && who && (who == what || who.contains(what));
	} else {
		var el = what;
		while(el) {
			if (el == who) {
				return true;
			}
			el = el.parentnode;
		}
		return false;
	}
};

spry.widget.utils.addeventlistener = function(element, eventtype, handler, capture)
{
	try
	{
		if (element.addeventlistener)
			element.addeventlistener(eventtype, handler, capture);
		else if (element.attachevent)
			element.attachevent("on" + eventtype, handler, capture);
	}
	catch (e) {}
};

spry.widget.utils.removeeventlistener = function(element, eventtype, handler, capture)
{
	try
	{
		if (element.removeeventlistener)
			element.removeeventlistener(eventtype, handler, capture);
		else if (element.detachevent)
			element.detachevent("on" + eventtype, handler, capture);
	}
	catch (e) {}
};