// SpryValidationTextarea.js - version 0.15 - 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.BrowserSniff = function() {
|
var b = navigator.appName.toString();
|
var up = navigator.platform.toString();
|
var ua = navigator.userAgent.toString();
|
|
this.mozilla = this.ie = this.opera = r = false;
|
var re_opera = /Opera.([0-9\.]*)/i;
|
var re_msie = /MSIE.([0-9\.]*)/i;
|
var re_gecko = /gecko/i;
|
var re_safari = /safari\/([\d\.]*)/i;
|
|
if (ua.match(re_opera)) {
|
r = ua.match(re_opera);
|
this.opera = true;
|
this.version = parseFloat(r[1]);
|
} else if (ua.match(re_msie)) {
|
r = ua.match(re_msie);
|
this.ie = true;
|
this.version = parseFloat(r[1]);
|
} else if (ua.match(re_safari)) {
|
this.safari = true;
|
this.version = 1.4;
|
} else if (ua.match(re_gecko)) {
|
var re_gecko_version = /rv:\s*([0-9\.]+)/i;
|
r = ua.match(re_gecko_version);
|
this.mozilla = true;
|
this.version = parseFloat(r[1]);
|
}
|
this.windows = this.mac = this.linux = false;
|
|
this.Platform = ua.match(/windows/i) ? "windows" :
|
(ua.match(/linux/i) ? "linux" :
|
(ua.match(/mac/i) ? "mac" :
|
ua.match(/unix/i)? "unix" : "unknown"));
|
this[this.Platform] = true;
|
this.v = this.version;
|
|
if (this.safari && this.mac && this.mozilla) {
|
this.mozilla = false;
|
}
|
};
|
|
Spry.is = new Spry.Widget.BrowserSniff();
|
|
|
Spry.Widget.ValidationTextarea = function(element, options){
|
|
options = Spry.Widget.Utils.firstValid(options, {});
|
this.flags = {locked: false};
|
this.options = {};
|
this.element = element;
|
this.init(element);
|
|
if (!this.isBrowserSupported()){
|
return;
|
}
|
|
options.useCharacterMasking = Spry.Widget.Utils.firstValid(options.useCharacterMasking, true);
|
options.hint = Spry.Widget.Utils.firstValid(options.hint, '');
|
options.isRequired = Spry.Widget.Utils.firstValid(options.isRequired, true);
|
options.additionalError = Spry.Widget.Utils.firstValid(options.additionalError, false);
|
|
Spry.Widget.Utils.setOptions(this, options);
|
Spry.Widget.Utils.setOptions(this.options, options);
|
|
if (options.additionalError)
|
this.additionalError = this.getElement(options.additionalError);
|
|
//make sure we validate at least on submit
|
var validateOn = ['submit'].concat(Spry.Widget.Utils.firstValid(this.options.validateOn, []));
|
validateOn = validateOn.join(",");
|
this.validateOn = 0;
|
this.validateOn = this.validateOn | (validateOn.indexOf('submit') != -1 ? Spry.Widget.ValidationTextarea.ONSUBMIT : 0);
|
this.validateOn = this.validateOn | (validateOn.indexOf('blur') != -1 ? Spry.Widget.ValidationTextarea.ONBLUR : 0);
|
this.validateOn = this.validateOn | (validateOn.indexOf('change') != -1 ? Spry.Widget.ValidationTextarea.ONCHANGE : 0);
|
|
if (Spry.Widget.ValidationTextarea.onloadDidFire){
|
this.attachBehaviors();
|
}else{
|
Spry.Widget.ValidationTextarea.loadQueue.push(this);
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.ONCHANGE = 1;
|
Spry.Widget.ValidationTextarea.ONBLUR = 2;
|
Spry.Widget.ValidationTextarea.ONSUBMIT = 4;
|
|
Spry.Widget.ValidationTextarea.INITIAL = 'Initial';
|
Spry.Widget.ValidationTextarea.REQUIRED = 'Required';
|
Spry.Widget.ValidationTextarea.INVALID = 'Invalid Format';
|
Spry.Widget.ValidationTextarea.MINIMUM = 'Minimum Number of Chars Not Met';
|
Spry.Widget.ValidationTextarea.MAXIMUM = 'Maximum Number of Chars Exceeded';
|
Spry.Widget.ValidationTextarea.VALID = 'Valid';
|
|
Spry.Widget.ValidationTextarea.prototype.init = function(element)
|
{
|
this.element = this.getElement(element);
|
this.event_handlers = [];
|
|
this.requiredClass = "textareaRequiredState";
|
this.invalidCharsMaxClass = "textareaMaxCharsState";
|
this.invalidCharsMinClass = "textareaMinCharsState";
|
this.validClass = "textareaValidState";
|
this.focusClass = "textareaFocusState";
|
this.hintClass = "textareaHintState";
|
this.textareaFlashClass = "textareaFlashState";
|
|
this.isMaxInvalid = false;
|
this.isMinInvalid = false;
|
this.isRequireInvalid = false;
|
|
this.safariClicked = false;
|
this.state = Spry.Widget.ValidationTextarea.INITIAL;
|
};
|
|
Spry.Widget.ValidationTextarea.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) {}
|
try { delete this.input; } catch(err) {}
|
try { delete this.counterEl; } catch(err) {}
|
try { delete this.form; } catch(err) {}
|
try { delete this.event_handlers; } catch(err) {}
|
try { this.cursorPosition.destroy(); } catch(err) {}
|
try { delete this.cursorPosition; } catch(err) {}
|
try { this.initialCursor.destroy(); } catch(err) {}
|
try { delete this.initialCursor; } 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.ValidationTextarea.prototype.isDisabled = function() {
|
return this.input && (this.input.disabled || this.input.readOnly) || !this.input;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.getElement = function(ele)
|
{
|
if (ele && typeof ele == "string")
|
return document.getElementById(ele);
|
return ele;
|
};
|
|
|
Spry.Widget.ValidationTextarea.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.ValidationTextarea.processLoadQueue = function(handler){
|
Spry.Widget.ValidationTextarea.onloadDidFire = true;
|
var q = Spry.Widget.ValidationTextarea.loadQueue;
|
var qlen = q.length;
|
for (var i = 0; i < qlen; i++){
|
q[i].attachBehaviors();
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.onloadDidFire = false;
|
Spry.Widget.ValidationTextarea.loadQueue = [];
|
Spry.Widget.ValidationTextarea.addLoadListener(Spry.Widget.ValidationTextarea.processLoadQueue);
|
Spry.Widget.ValidationTextarea.addLoadListener(function(){
|
Spry.Widget.Utils.addEventListener(window, "unload", Spry.Widget.Form.destroyAll, false);
|
});
|
|
Spry.Widget.ValidationTextarea.prototype.isBrowserSupported = function()
|
{
|
return Spry.is.ie && Spry.is.v >= 5 && Spry.is.windows
|
||
|
Spry.is.mozilla && Spry.is.v >= 1.4
|
||
|
Spry.is.safari
|
||
|
Spry.is.opera && Spry.is.v >= 9;
|
};
|
|
/*
|
* register our input to different event notifiers
|
*
|
*/
|
Spry.Widget.ValidationTextarea.prototype.attachBehaviors = function()
|
{
|
if (this.element){
|
if (this.element.nodeName == "TEXTAREA") {
|
this.input = this.element;
|
} else {
|
this.input = Spry.Widget.Utils.getFirstChildWithNodeNameAtAnyLevel(this.element, "TEXTAREA");
|
}
|
}
|
if (this.options && this.options.counterType && (this.options.counterType == 'chars_count' || this.options.counterType == 'chars_remaining')){
|
this.counterEl = document.getElementById(this.options.counterId);
|
this.counterChar();
|
}
|
|
if (this.input) {
|
this.input.setAttribute("AutoComplete", "off");
|
this.putHint();
|
this.cursorPosition = new Spry.Widget.SelectionDescriptor(this.input);
|
|
var self = this;
|
this.event_handlers = [];
|
|
//attach the pattern related event handlers (to stop invalid keys)
|
if (this.useCharacterMasking) {
|
if (Spry.is.ie){
|
this.event_handlers.push([this.input, "propertychange", function(e) { return self.onKeyEvent(e || event); }]);
|
this.event_handlers.push([this.input, "drop", function(e) { return self.onDrop (e || event); }]);
|
this.event_handlers.push([this.input, "keypress", function(e) { return self.onKeyPress(e || event); }]);
|
} else{
|
this.event_handlers.push([this.input, "keydown", function(e) { return self.onKeyDown(e); }]);
|
this.event_handlers.push([this.input, "keypress", function(e) { return self.safariKeyPress(e); }]);
|
this.event_handlers.push([this.input, "keyup", function(e) { return self.safariValidate(e); }]);
|
if (Spry.is.safari){
|
this.event_handlers.push([this.input, "mouseup", function(e) { return self.safariMouseUp(e); }]);
|
this.event_handlers.push([this.input, "mousedown", function(e) { return self.safariMouseDown(e); }]);
|
} else {
|
//Firefox bug: 355219
|
//this.event_handlers.push([this.input, "input", function(e) { self.onKeyEvent(e); return true;}]);
|
this.event_handlers.push([this.input, "dragdrop", function(e) { return self.onKeyEvent(e); }]);
|
this.event_handlers.push([this.input, "dragenter", function(e) { self.removeHint(); return self.onKeyDown(e); }]);
|
this.event_handlers.push([this.input, "dragexit", function(e) { return self.putHint(); }]);
|
}
|
}
|
// we need to save an initial state in case of invalid input
|
this.event_handlers.push([this.input, "keydown", function(e) {return self.onKeyDown(e || event); }]);
|
}
|
|
this.event_handlers.push([this.input, "focus", function(e) { return self.onFocus(e || event); }]);
|
this.event_handlers.push([this.input, "mousedown", function(e) { return self.onMouseDown(e || event); }]);
|
this.event_handlers.push([this.input, "blur", function(e) { return self.onBlur(e || event); }]);
|
|
if (this.validateOn & Spry.Widget.ValidationTextarea.ONCHANGE){
|
if (Spry.is.ie){
|
this.event_handlers.push([this.input, "propertychange", function(e) { return self.onChange(e || event); }]);
|
this.event_handlers.push([this.input, "drop", function(e) { return self.onChange(e || event); }]);
|
} else{
|
this.event_handlers.push([this.input, "keydown", function(e) { return self.onKeyDown(e); }]);
|
this.event_handlers.push([this.input, "keypress", function(e) { return self.safariChangeKeyPress(e); }]);
|
this.event_handlers.push([this.input, "keyup", function(e) { return self.safariChangeValidate(e); }]);
|
if (Spry.is.safari){
|
this.event_handlers.push([this.input, "mouseup", function(e) { return self.safariChangeMouseUp(e); }]);
|
this.event_handlers.push([this.input, "mousedown", function(e) { return self.safariMouseDown(e); }]);
|
} else {
|
// Firefox bug: 355219
|
//this.event_handlers.push([this.input, "input", function(e) { return self.onChange(e); }]);
|
this.event_handlers.push([this.input, "dragdrop", function(e) {return self.onChange(e); }]);
|
this.event_handlers.push([this.input, "dragenter", function(e) { self.removeHint(); return self.onKeyDown(e); }]);
|
this.event_handlers.push([this.input, "dragexit", function(e) { return self.putHint(); }]);
|
}
|
}
|
}
|
// The counter should be called directly when no enforcement or change restrictions exists
|
if (! (this.validateOn & Spry.Widget.ValidationTextarea.ONCHANGE) && !this.useCharacterMasking){
|
if (Spry.is.ie){
|
this.event_handlers.push([this.input, "propertychange", function(e) { return self.counterChar(); }]);
|
this.event_handlers.push([this.input, "drop", function(e) { return self.counterChar(); }]);
|
} else{
|
this.event_handlers.push([this.input, "keypress", function(e) { return self.counterChar(); }]);
|
this.event_handlers.push([this.input, "keyup", function(e) { return self.counterChar(); }]);
|
if (Spry.is.safari){
|
this.event_handlers.push([this.input, "mouseup", function(e) { return self.counterChar(); }]);
|
} else {
|
// Firefox bug: 355219
|
//this.event_handlers.push([this.input, "input", function(e) { return self.onChange(e); }]);
|
this.event_handlers.push([this.input, "dragdrop", function(e) {return self.counterChar(); }]);
|
}
|
}
|
}
|
|
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);
|
}
|
|
this.form = Spry.Widget.Utils.getFirstParentWithNodeName(this.input, "FORM");
|
if (this.form) {
|
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);
|
}
|
}
|
this.saveState();
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onTyping = function(e){
|
if (this.input.disabled == true || this.input.readOnly == true){
|
return;
|
}
|
|
if (!this.initialCursor){
|
this.initialCursor = this.cursorPosition;
|
}
|
// on IE a stack overflow appears
|
if (this.flags.locked){
|
return true;
|
}
|
|
var val = this.input.value;
|
|
var ret = true;
|
|
if (this.flags.hintOn){
|
return true;
|
}
|
if (e && this.input && this.options && this.options.maxChars > 0 && ret){
|
if ( val.length > this.options.maxChars &&
|
((!Spry.Widget.Utils.isSpecialKey(e) && this.cursorPosition.start == this.cursorPosition.end) ||
|
(Spry.Widget.Utils.isSpecialKey(e) && val != this.initialValue) ||
|
this.cursorPosition.start != this.cursorPosition.end)
|
){
|
// cut the extra chars and display error
|
this.flags.locked = true;
|
var initial = this.initialValue;
|
var start = this.initialCursor.start;
|
var end = this.initialCursor.end;
|
if (initial.length && this.initialCursor.end < initial.length) {
|
// we try to behave more like maxlength textfield
|
var tmp = end - start + this.options.maxChars - initial.length;
|
var newValue = initial.substring(0, start) + val.substring(start, start+tmp) + initial.substring(end, initial.length < this.options.maxChars ? initial.length:this.options.maxChars);
|
end = start + tmp;
|
}else{
|
var newValue = val.substring(0, this.options.maxChars);
|
end = start = this.options.maxChars;
|
}
|
if (Spry.is.ie) {
|
this.input.innerText = newValue;
|
} else {
|
this.input.value = newValue;
|
}
|
this.redTextFlash();
|
this.cursorPosition.moveTo(end, end);
|
this.flags.locked = false;
|
ret = false;
|
} else{
|
this.setState(Spry.Widget.ValidationTextarea.VALID);
|
this.isMaxInvalid = false;
|
}
|
}
|
this.counterChar();
|
return ret;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.validateMinRequired = function(val){
|
var oldInvalid = false;
|
if (typeof this.notFireMinYet == 'undefined'){
|
this.notFireMinYet = false;
|
}else{
|
oldInvalid = true;
|
this.notFireMinYet = true;
|
}
|
if (this.onBlurOn){
|
this.notFireMinYet = true;
|
}else if (!this.onKeyEventOn){
|
this.notFireMinYet = true;
|
}
|
|
if (this.input && this.options && this.options.isRequired){
|
if (val.length > 0 && this.isRequireInvalid && (!this.hint || (this.hint && !this.flags.hintOn) || (this.hint && val != this.hint))){
|
this.switchClassName(this.validClass);
|
this.setState(Spry.Widget.ValidationTextarea.VALID);
|
this.isRequireInvalid = false;
|
}else if ((val.length == 0 || !(!this.hint || (this.hint && !this.flags.hintOn) || (this.hint && val != this.hint))) && (!this.isRequireInvalid || oldInvalid)){
|
if (this.notFireMinYet || Spry.is.ie){
|
this.switchClassName(this.requiredClass);
|
this.setState(Spry.Widget.ValidationTextarea.REQUIRED);
|
}
|
this.isRequireInvalid = true;
|
this.isMinInvalid = false;
|
}
|
}
|
if (this.input && this.options && this.options.minChars > 0 && !this.isRequireInvalid){
|
if (val.length >= this.options.minChars && (!this.hint || (this.hint && !this.flags.hintOn) || (this.hint && val != this.hint)) && this.isMinInvalid){
|
this.switchClassName(this.validClass);
|
this.setState(Spry.Widget.ValidationTextarea.VALID);
|
this.isMinInvalid = false;
|
}else if ( (val.length < this.options.minChars || (this.hint && val == this.hint && this.flags.hintOn)) && !this.isMinInvalid){
|
this.switchClassName(this.invalidCharsMinClass);
|
this.setState(Spry.Widget.ValidationTextarea.MINIMUM);
|
this.isMinInvalid = true;
|
}
|
}
|
};
|
Spry.Widget.ValidationTextarea.prototype.counterChar = function(){
|
if (!this.counterEl || !this.options || !this.options.counterType || (this.options.counterType != 'chars_remaining' && this.options.counterType != 'chars_count')){
|
return;
|
}
|
|
if (this.options.counterType == 'chars_remaining') {
|
if (this.options.maxChars > 0){
|
if (this.flags.hintOn){
|
this.setCounterElementValue(this.options.maxChars);
|
} else {
|
if (this.options.maxChars > this.input.value.length){
|
this.setCounterElementValue(this.options.maxChars - this.input.value.length);
|
}else{
|
this.setCounterElementValue(0);
|
}
|
}
|
}
|
} else {
|
if (this.flags.hintOn){
|
this.setCounterElementValue(0);
|
} else {
|
if (this.useCharacterMasking && typeof this.options.maxChars != 'undefined' && this.options.maxChars < this.input.value.length){
|
this.setCounterElementValue(this.options.maxChars);
|
} else {
|
this.setCounterElementValue(this.input.value.length);
|
}
|
}
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.setCounterElementValue = function(val){
|
if ( this.counterEl.nodeName.toLowerCase() != 'input' &&
|
this.counterEl.nodeName.toLowerCase() != 'textarea' &&
|
this.counterEl.nodeName.toLowerCase() != 'select' &&
|
this.counterEl.nodeName.toLowerCase() != 'img'){
|
this.counterEl.innerHTML = val;
|
}
|
};
|
Spry.Widget.ValidationTextarea.prototype.reset = function() {
|
this.removeHint();
|
this.removeClassName(this.requiredClass);
|
this.removeClassName(this.invalidCharsMinClass);
|
this.removeClassName(this.invalidCharsMaxClass);
|
this.removeClassName(this.validClass);
|
this.setState(Spry.Widget.ValidationTextarea.INITIAL);
|
var self = this;
|
setTimeout(function() {self.putHint();self.counterChar();}, 10);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.validate = function(){
|
if (this.input.disabled == true || this.input.readOnly == true){
|
return true;
|
}
|
|
var val = this.input.value;
|
this.validateMinRequired(val);
|
|
var ret = !this.isMinInvalid && !this.isRequireInvalid;
|
|
if (ret && this.options.maxChars > 0 && !this.useCharacterMasking){
|
if (val.length <= this.options.maxChars || (this.hint && this.hint == val && this.flags.hintOn)) {
|
this.switchClassName(this.validClass);
|
this.setState(Spry.Widget.ValidationTextarea.VALID);
|
this.isMaxInvalid = false;
|
}else{
|
this.switchClassName(this.invalidCharsMaxClass);
|
this.setState(Spry.Widget.ValidationTextarea.MAXIMUM);
|
this.isMaxInvalid = true;
|
}
|
}
|
ret = ret && !this.isMaxInvalid;
|
if (ret) {
|
this.switchClassName(this.validClass);
|
}
|
this.counterChar();
|
return ret;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.setState = function(newstate){
|
this.state = newstate;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.getState = function(){
|
return this.state;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.removeHint = function()
|
{
|
if (this.flags.hintOn)
|
{
|
this.flags.locked = true;
|
this.input.value = "";
|
this.flags.locked = false;
|
this.flags.hintOn = false;
|
this.removeClassName(this.hintClass);
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.putHint = function()
|
{
|
if(this.hint && this.input.value == "") {
|
this.flags.hintOn = true;
|
this.input.value = this.hint;
|
this.addClassName(this.hintClass);
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.redTextFlash = function()
|
{
|
var self = this;
|
this.addClassName(this.textareaFlashClass);
|
setTimeout(function() {
|
self.removeClassName(self.textareaFlashClass)
|
}, 200);
|
};
|
|
|
Spry.Widget.ValidationTextarea.prototype.onKeyPress = function(e)
|
{
|
//ENTER has length 2 on IE Windows, so will exceed maxLength on proximity
|
if (Spry.is.ie && Spry.is.windows && e.keyCode == 13) {
|
if ( (this.initialCursor.length + this.options.maxChars - this.input.value.length) < 2) {
|
Spry.Widget.Utils.stopEvent(e);
|
return false;
|
}
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onKeyDown = function(e)
|
{
|
this.saveState();
|
this.keyCode = e.keyCode;
|
return true;
|
};
|
|
/*
|
* hadle for the max chars restrictions
|
* if key pressed or the input text is invalid it returns false
|
*
|
*/
|
Spry.Widget.ValidationTextarea.prototype.onKeyEvent = function(e){
|
// on IE we look only for this input value changes
|
if (e.type == 'propertychange' && e.propertyName != 'value'){
|
return true;
|
}
|
|
var allow = this.onTyping(e);
|
|
if (!allow){
|
Spry.Widget.Utils.stopEvent(e);
|
}
|
//return allow;
|
};
|
|
/*
|
* handle for the min or required value
|
* if the input text is invalid it returns false
|
*
|
*/
|
Spry.Widget.ValidationTextarea.prototype.onChange = function(e){
|
if (Spry.is.ie && e && e.type == 'propertychange' && e.propertyName != 'value') {
|
return true;
|
}
|
|
if (this.flags.drop) {
|
//delay this if it's a drop operation
|
var self = this;
|
setTimeout(function() {
|
self.flags.drop = false;
|
self.onChange(null);
|
}, 0);
|
return true;
|
}
|
if (this.flags.hintOn) {
|
return true;
|
}
|
this.onKeyEventOn = true;
|
var answer = this.validate();
|
this.onKeyEventOn = false;
|
return answer;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onMouseDown = function(e)
|
{
|
if (this.flags.active) {
|
//mousedown fires before focus
|
//avoid double saveState on first focus by mousedown by checking if the control has focus
|
//do nothing if it's not focused because saveState will be called onfocus
|
this.saveState();
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onDrop = function(e)
|
{
|
//mark that a drop operation is in progress to avoid race conditions with event handlers for other events
|
//especially onchange and onfocus
|
this.flags.drop = true;
|
this.removeHint();
|
|
if (Spry.is.ie) {
|
var rng = document.body.createTextRange();
|
rng.moveToPoint(e.x, e.y);
|
rng.select();
|
}
|
|
this.saveState();
|
this.flags.active = true;
|
this.addClassName(this.focusClass);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onFocus = function(e)
|
{
|
if (this.flags.drop) {
|
return;
|
}
|
this.removeHint();
|
this.saveState();
|
this.flags.active = true;
|
this.addClassName(this.focusClass);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.onBlur = function(e){
|
this.removeClassName(this.focusClass);
|
|
if (this.validateOn & Spry.Widget.ValidationTextarea.ONBLUR) {
|
this.onBlurOn = true;
|
this.validate();
|
this.onBlurOn = false;
|
}
|
|
this.flags.active = false;
|
var self = this;
|
setTimeout(function() {self.putHint();}, 10);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariMouseDown = function(e){
|
this.safariClicked = true;
|
};
|
Spry.Widget.ValidationTextarea.prototype.safariChangeMouseUp = function(e){
|
if (!this.safariClicked){
|
this.onKeyDown(e);
|
return this.safariChangeValidate(e, false);
|
}else{
|
this.safariClicked = false;
|
return true;
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariMouseUp = function(e){
|
if (!this.safariClicked){
|
this.onKeyDown(e);
|
return this.safariValidate(e, false);
|
}else{
|
this.safariClicked = false;
|
return true;
|
}
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariKeyPress = function(e){
|
this.safariFlag = new Date();
|
return this.safariValidate(e, true);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariValidate = function(e, recall)
|
{
|
if (e.keyCode && Spry.Widget.Utils.isSpecialKey(e) && e.keyCode != 8 && e.keyCode != 46){
|
return true;
|
}
|
var answer = this.onTyping(e);
|
|
// the answer to this is not yet final - we schedule another closing check
|
if (new Date() - this.safariFlag < 1000 && recall){
|
var self = this;
|
setTimeout(function(){self.safariValidate(e, false);}, 1000);
|
}
|
return answer;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariChangeKeyPress = function(e){
|
this.safariChangeFlag = new Date();
|
return this.safariChangeValidate(e, true);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.safariChangeValidate = function(e, recall){
|
|
if(e.keyCode && Spry.Widget.Utils.isSpecialKey(e) && e.keyCode != 8 && e.keyCode != 46){
|
return true;
|
}
|
var answer = this.onChange(e);
|
|
// the answer to this is not yet final - we schedule another closing check
|
if (new Date() - this.safariChangeFlag < 1000 && recall){
|
var self = this;
|
setTimeout(function(){ self.safariChangeValidate(e, false);}, 1000 - new Date() + this.safariChangeFlag);
|
}
|
return answer;
|
};
|
|
/*
|
* save an initial state of the input to restore if the value is invalid
|
*
|
*/
|
Spry.Widget.ValidationTextarea.prototype.saveState = function(e){
|
|
// we don't need this initial value that is already invalid
|
if (this.options.maxChars > 0 && this.input.value.length > this.options.maxChars){
|
return;
|
}
|
this.cursorPosition.update();
|
if (!this.flags.hintOn){
|
this.initialValue = this.input.value;
|
}else{
|
this.initialValue = '';
|
}
|
this.initialCursor = this.cursorPosition;
|
return true;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.checkClassName = function(ele, className){
|
if (!ele || !className){
|
return false;
|
}
|
if (typeof ele == 'string' ) {
|
ele = document.getElementById(ele);
|
if (!ele){
|
return false;
|
}
|
}
|
if (!ele.className){
|
ele.className = ' ';
|
}
|
return ele;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.switchClassName = function (className){
|
var classes = [this.invalidCharsMaxClass, this.validClass, this.requiredClass, this.invalidCharsMinClass];
|
|
for (var k = 0; k < classes.length; k++){
|
if (classes[k] != className){
|
this.removeClassName(classes[k]);
|
}
|
}
|
|
this.addClassName(className);
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.addClassName = function(clssName){
|
var ele = this.checkClassName(this.element, clssName);
|
var add = this.checkClassName(this.additionalError, clssName);
|
|
if (!ele || ele.className.search(new RegExp("\\b" + clssName + "\\b")) != -1){
|
return;
|
}
|
this.element.className += ' ' + clssName;
|
if (add)
|
add.className += ' ' + clssName;
|
};
|
|
Spry.Widget.ValidationTextarea.prototype.removeClassName = function(className){
|
var ele = this.checkClassName(this.element, className);
|
var add = this.checkClassName(this.additionalError, className);
|
if (!ele){
|
return;
|
}
|
ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), '');
|
if (add){
|
add.className = add.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), '');
|
}
|
};
|
|
/**
|
* SelectionDescriptor is a wrapper for input type text selection methods and properties
|
* as implemented by various browsers
|
*/
|
Spry.Widget.SelectionDescriptor = function (element)
|
{
|
this.element = element;
|
this.update();
|
};
|
|
Spry.Widget.SelectionDescriptor.prototype.update = function()
|
{
|
if (Spry.is.ie && Spry.is.windows) {
|
var sel = this.element.ownerDocument.selection;
|
if (this.element.nodeName == "TEXTAREA") {
|
if (sel.type != 'None') {
|
try{var range = sel.createRange();}catch(err){return;}
|
if (range.parentElement() == this.element){
|
var range_all = this.element.ownerDocument.body.createTextRange();
|
range_all.moveToElementText(this.element);
|
for (var sel_start = 0; range_all.compareEndPoints('StartToStart', range) < 0; sel_start ++){
|
range_all.moveStart('character', 1);
|
}
|
this.start = sel_start;
|
// create a selection of the whole this.element
|
range_all = this.element.ownerDocument.body.createTextRange();
|
range_all.moveToElementText(this.element);
|
for (var sel_end = 0; range_all.compareEndPoints('StartToEnd', range) < 0; sel_end++){
|
range_all.moveStart('character', 1);
|
}
|
this.end = sel_end;
|
this.length = this.end - this.start;
|
// get selected and surrounding text
|
this.text = range.text;
|
}
|
}
|
} else if (this.element.nodeName == "INPUT"){
|
try{this.range = sel.createRange();}catch(err){return;}
|
this.length = this.range.text.length;
|
var clone = this.range.duplicate();
|
this.start = -clone.moveStart("character", -10000);
|
clone = this.range.duplicate();
|
clone.collapse(false);
|
this.end = -clone.moveStart("character", -10000);
|
this.text = this.range.text;
|
}
|
} else {
|
var tmp = this.element;
|
var selectionStart = 0;
|
var selectionEnd = 0;
|
|
try { selectionStart = tmp.selectionStart;} catch(err) {}
|
try { selectionEnd = tmp.selectionEnd;} catch(err) {}
|
|
if (Spry.is.safari) {
|
if (selectionStart == 2147483647) {
|
selectionStart = 0;
|
}
|
if (selectionEnd == 2147483647) {
|
selectionEnd = 0;
|
}
|
}
|
this.start = selectionStart;
|
this.end = selectionEnd;
|
this.length = selectionEnd - selectionStart;
|
this.text = this.element.value.substring(selectionStart, selectionEnd);
|
}
|
};
|
Spry.Widget.SelectionDescriptor.prototype.destroy = function() {
|
try { delete this.range} catch(err) {}
|
try { delete this.element} catch(err) {}
|
};
|
|
Spry.Widget.SelectionDescriptor.prototype.moveTo = function(start, end)
|
{
|
if (Spry.is.ie && Spry.is.windows) {
|
if (this.element.nodeName == "TEXTAREA") {
|
var ta_range = this.element.createTextRange();
|
this.range = this.element.createTextRange();
|
this.range.move("character", start);
|
this.range.moveEnd("character", end - start);
|
|
var c1 = this.range.compareEndPoints("StartToStart", ta_range);
|
if (c1 < 0) {
|
this.range.setEndPoint("StartToStart", ta_range);
|
}
|
|
var c2 = this.range.compareEndPoints("EndToEnd", ta_range);
|
if (c2 > 0) {
|
this.range.setEndPoint("EndToEnd", ta_range);
|
}
|
} else if (this.element.nodeName == "INPUT"){
|
this.range = this.element.ownerDocument.selection.createRange();
|
this.range.move("character", -10000);
|
this.start = this.range.moveStart("character", start);
|
this.end = this.start + this.range.moveEnd("character", end - start);
|
}
|
this.range.select();
|
} else {
|
this.start = start;
|
try { this.element.selectionStart = start; } catch(err) {}
|
this.end = end;
|
try { this.element.selectionEnd = end; } catch(err) {}
|
}
|
this.ignore = true;
|
this.update();
|
};
|
|
//////////////////////////////////////////////////////////////////////
|
//
|
// 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.firstValid = function() {
|
var ret = null;
|
for(var i=0; i<Spry.Widget.Utils.firstValid.arguments.length; i++) {
|
if (typeof(Spry.Widget.Utils.firstValid.arguments[i]) != 'undefined') {
|
ret = Spry.Widget.Utils.firstValid.arguments[i];
|
break;
|
}
|
}
|
return ret;
|
};
|
|
Spry.Widget.Utils.specialSafariNavKeys = ",63232,63233,63234,63235,63272,63273,63275,63276,63277,63289,";
|
|
Spry.Widget.Utils.specialCharacters = ",8,9,16,17,18,20,27,33,34,35,36,37,38,39,40,45,46,91,92,93,144,192,63232,";
|
Spry.Widget.Utils.specialCharacters += Spry.Widget.Utils.specialSafariNavKeys;
|
|
Spry.Widget.Utils.isSpecialKey = function (ev) {
|
return Spry.Widget.Utils.specialCharacters.indexOf("," + ev.keyCode + ",") != -1;
|
};
|
|
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) {}
|
};
|
|
Spry.Widget.Utils.stopEvent = function(ev)
|
{
|
try
|
{
|
this.stopPropagation(ev);
|
this.preventDefault(ev);
|
}
|
catch (e) {}
|
};
|
|
/**
|
* Stops event propagation
|
* @param {Event} ev the event
|
*/
|
Spry.Widget.Utils.stopPropagation = function(ev)
|
{
|
if (ev.stopPropagation)
|
{
|
ev.stopPropagation();
|
}
|
else
|
{
|
ev.cancelBubble = true;
|
}
|
};
|
|
/**
|
* Prevents the default behavior of the event
|
* @param {Event} ev the event
|
*/
|
Spry.Widget.Utils.preventDefault = function(ev)
|
{
|
if (ev.preventDefault)
|
{
|
ev.preventDefault();
|
}
|
else
|
{
|
ev.returnValue = false;
|
}
|
};
|
