// SpryValidationCheckbox.js - version 0.10 - Spry Pre-Release 1.6
//
// 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.ValidationCheckbox = 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.ValidationCheckbox.ONSUBMIT : 0);
    this.validateOn = this.validateOn | (validateOn.indexOf('blur') != -1 ? Spry.Widget.ValidationCheckbox.ONBLUR : 0);
    this.validateOn = this.validateOn | (validateOn.indexOf('change') != -1 ? Spry.Widget.ValidationCheckbox.ONCHANGE : 0);

    // sanity checks
    if (!isNaN(this.minSelections))
    {
        this.minSelections = (this.minSelections > 0) ? parseInt(this.minSelections, 10) : null;
    }
    if (!isNaN(this.maxSelections))
    {
        this.maxSelections = (this.maxSelections > 0) ? parseInt(this.maxSelections, 10) : null;
    }

    if (this.additionalError)
        this.additionalError = this.getElement(this.additionalError);
    // 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.ValidationCheckbox.onloadDidFire)
        this.attachBehaviors();
    else
        Spry.Widget.ValidationCheckbox.loadQueue.push(this);
};

Spry.Widget.ValidationCheckbox.ONCHANGE = 1;
Spry.Widget.ValidationCheckbox.ONBLUR = 2;
Spry.Widget.ValidationCheckbox.ONSUBMIT = 4;

Spry.Widget.ValidationCheckbox.prototype.init = function (element)
{
    this.element = this.getElement(element);
    this.checkboxElements = null;
    this.additionalError = false;
    this.form = null;
    this.event_handlers = [];

    // this.element can be either the container (<span>)
    // or the <input type="checkbox"> element, when no error messages are used.
    this.hasFocus = false;
    this.requiredClass = "checkboxRequiredState";
    this.minSelectionsClass = "checkboxMinSelectionsState";
    this.maxSelectionsClass = "checkboxMaxSelectionsState";
    this.focusClass = "checkboxFocusState";
    this.validClass = "checkboxValidState";

    this.isRequired = true;

    this.minSelections = null;
    this.maxSelections = null;

    this.validateOn = ["submit"];  // change, submit (blur ?)
};

Spry.Widget.ValidationCheckbox.prototype.destroy = function ()
{
    if (this.event_handlers)
        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) { }
    if (this.checkboxElements)
        for (var i = 0; i < this.checkboxElements.length; i++)
        {
            try { delete this.checkboxElements[i]; } catch (err) { }
        }
    try { delete this.checkboxElements; } 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.ValidationCheckbox.onloadDidFire = false;
Spry.Widget.ValidationCheckbox.loadQueue = [];

Spry.Widget.ValidationCheckbox.prototype.getElement = function (ele)
{
    if (ele && typeof ele == "string")
        return document.getElementById(ele);
    return ele;
};

Spry.Widget.ValidationCheckbox.processLoadQueue = function (handler)
{
    Spry.Widget.ValidationCheckbox.onloadDidFire = true;
    var q = Spry.Widget.ValidationCheckbox.loadQueue;
    var qlen = q.length;
    for (var i = 0; i < qlen; i++)
        q[i].attachBehaviors();
};

Spry.Widget.ValidationCheckbox.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.ValidationCheckbox.addLoadListener(Spry.Widget.ValidationCheckbox.processLoadQueue);
Spry.Widget.ValidationCheckbox.addLoadListener(function ()
{
    Spry.Widget.Utils.addEventListener(window, "unload", Spry.Widget.Form.destroyAll, false);
});

Spry.Widget.ValidationCheckbox.prototype.attachBehaviors = function ()
{
    if (!this.element)
        return;
    // find the INPUT type="checkbox" element(s) inside current container
    if (this.element.nodeName == "INPUT")
    {
        this.checkboxElements = [this.element];
    } else
    {
        this.checkboxElements = this.getCheckboxes();
    }
    if (this.checkboxElements)
    {
        var self = this;
        this.event_handlers = [];

        var qlen = this.checkboxElements.length;
        for (var i = 0; i < qlen; i++)
        {
            // focus
            this.event_handlers.push([this.checkboxElements[i], "focus", function (e) { return self.onFocus(e); } ]);
            // blur
            this.event_handlers.push([this.checkboxElements[i], "blur", function (e) { return self.onBlur(e); } ]);
            // add click instead of onChange
            if (this.validateOn & Spry.Widget.ValidationCheckbox.ONCHANGE)
            {
                this.event_handlers.push([this.checkboxElements[i], "click", function (e) { return self.onClick(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.element, "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.ValidationCheckbox.prototype.getCheckboxes = function ()
{
    var arrCheckboxes;
    var elements = this.element.getElementsByTagName("INPUT");
    if (elements.length)
    {
        arrCheckboxes = [];
        var qlen = elements.length;
        for (var i = 0; i < qlen; i++)
        {
            if (elements[i].type == "checkbox")
            {
                arrCheckboxes.push(elements[i]);
            }
        }
        return arrCheckboxes;
    }
    return null;
};

Spry.Widget.ValidationCheckbox.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.ValidationCheckbox.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.ValidationCheckbox.prototype.onFocus = function (e)
{
    var eventCheckbox = (e.srcElement != null) ? e.srcElement : e.target;
    if (eventCheckbox.disabled) return;

    this.hasFocus = true;
    this.addClassName(this.element, this.focusClass);
    this.addClassName(this.additionalError, this.focusClass);
};

Spry.Widget.ValidationCheckbox.prototype.onBlur = function (e)
{
    var eventCheckbox = (e.srcElement != null) ? e.srcElement : e.target;
    if (eventCheckbox.disabled) return;

    this.hasFocus = false;
    var doValidation = false;
    if (this.validateOn & Spry.Widget.ValidationCheckbox.ONBLUR)
        doValidation = true;
    if (doValidation)
        this.validate();
    this.removeClassName(this.element, this.focusClass);
    this.removeClassName(this.additionalError, this.focusClass);

};

Spry.Widget.ValidationCheckbox.prototype.onClick = function (e)
{
    var eventCheckbox = (e.srcElement != null) ? e.srcElement : e.target;
    if (eventCheckbox.disabled) return;

    this.validate();
};

Spry.Widget.ValidationCheckbox.prototype.reset = function ()
{
    this.removeClassName(this.element, this.validClass);
    this.removeClassName(this.element, this.requiredClass);
    this.removeClassName(this.element, this.minSelectionsClass);
    this.removeClassName(this.element, this.maxSelectionsClass);
    this.removeClassName(this.additionalError, this.validClass);
    this.removeClassName(this.additionalError, this.requiredClass);
    this.removeClassName(this.additionalError, this.minSelectionsClass);
    this.removeClassName(this.additionalError, this.maxSelectionsClass);
};

Spry.Widget.ValidationCheckbox.prototype.validate = function ()
{
    this.reset();

    var nochecked = 0;
    if (this.checkboxElements)
    {
        var qlen = this.checkboxElements.length;
        for (var i = 0; i < qlen; i++)
        {
            if (!this.checkboxElements[i].disabled && this.checkboxElements[i].checked)
            {
                nochecked++;
            }
        }
    }

    // check isRequired
    if (this.isRequired)
    {
        if (nochecked == 0)
        {
            this.addClassName(this.element, this.requiredClass);
            this.addClassName(this.additionalError, this.requiredClass);
            return false;
        }
    }
    if (this.minSelections)
    {
        if (this.minSelections > nochecked)
        {
            this.addClassName(this.element, this.minSelectionsClass);
            this.addClassName(this.additionalError, this.minSelectionsClass);
            return false;
        }
    }
    if (this.maxSelections)
    {
        if (this.maxSelections < nochecked)
        {
            this.addClassName(this.element, this.maxSelectionsClass);
            this.addClassName(this.additionalError, this.maxSelectionsClass);
            return false;
        }
    }
    this.addClassName(this.element, this.validClass);
    this.addClassName(this.additionalError, this.validClass);
    return true;
};

Spry.Widget.ValidationCheckbox.prototype.isDisabled = function ()
{
    var ret = true;
    if (this.checkboxElements)
    {
        var qlen = this.checkboxElements.length;
        for (var i = 0; i < qlen; i++)
        {
            if (!this.checkboxElements[i].disabled)
            {
                ret = false;
                break;
            }
        }
    }
    return ret;
};

//////////////////////////////////////////////////////////////////////
//
// 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.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) { }
};