/*
 * Copyright (c) 1995-2005 Macromedia, Inc. All rights reserved. 
*/
var KT_focusedEl = null;

/********** 
KT_validateSingle function
description:
Validates single character agains single mask component
params: 
ascchar: character
single character, to test if it is correct in the context of the mask character 
maskchar: character
single mask character, see below for meaning
returns: 
boolean
 **********/
function KT_validateSingle(ascchar, maskchar) {
var cchar = ascchar.charCodeAt(0);
switch (maskchar) {
case "9": //numeric
if (cchar < 58 && cchar > 47) {
return true;
}
break;
case "A": //letter
if ((cchar < 91 && cchar > 64) || (cchar < 123 && cchar > 96)) {
return true;
}
break;
case "X": //letter or numeric
if ((cchar < 91 && cchar > 64) || (cchar < 123 && cchar > 96) || (cchar < 58 && cchar > 47)) {
return true;
}
break;
case "?": //any character
return true;
break;
default:
return true;
break;
}
}

/********** 
KT_maskDefaultValue function
description:
Called with a special mask character, returns the default value for that type of mask
params:
maskchar: character
single mask character, see below for meaning
returns:
character
**********/
function KT_maskDefaultValue(maskchar) {
switch (maskchar) {
case "9": //numeric
return '0';
break;
case "A": //letter
return 'a';
break;
case "X": //letter or numeric
return '0';
break;
case "?": //any character
return '0';
break;
default:
return '0';
break;
}
}

/********** 
KT_isSpecialChar function
description:
Checks if the parameter is a special mask character
params:
ascchar: character
Special mask characters: 
9 - numeric
A - letters
X - letter or number
? - any character
returns:
boolean
**********/
function KT_isSpecialChar(ascchar) {
if (ascchar == '9' || ascchar == 'A' || ascchar == 'X' || ascchar == '?')  {
return true;
} else {
return false;
}
}

/**********
mask_onValueChanged function
description:
Called when 
- the user types something in the input
- the input loses the focus
It validates the input's value against the input's mask
params: 
none
returns:
none
**********/
function mask_onValueChanged() {
if ((typeof window.getSelection == 'undefined' && typeof document.selection == 'undefined')) {
// if the current browser is not compatible, do nothing
return;
}

if (KT_focusedEl == null || KT_focusedEl.mask == null || KT_focusedEl.mask == '') {
return;
}

var mask = KT_focusedEl.mask;
var val = KT_focusedEl.value;
var i = 0;
var moveCursor = false;

if (val == KT_focusedEl.oldText) {
// if the field content did not change since the last update, do nothing
return;
}
if (val.length > mask.length) {
// strip trailing characters if text length is bigger than mask length
val = val.substr(0, mask.length);
moveCursor = true;
}
for (; i < mask.length ; i++) {
if (val.charCodeAt(i).toString() != 'NaN') {
//if the char is inserted
if (KT_isSpecialChar(mask.charAt(i))) {
if (KT_validateSingle(val.charAt(i), mask.charAt(i))) {
//character is correct, go to next
continue;
} else {
//revert to the last known good value, increase index to break loop
val = KT_focusedEl.oldText;
i = mask.length;
break;
}
} else {
//normal character in the mask
if (val.charAt(i) != mask.charAt(i)) {
//if the character is different from the mask
if (i == val.length - 1) {
//append last character and move cursor to the end
var lastChar = val.substr(val.length -1, val.length);
val = val.substr(0, val.length -1) + mask.charAt(i) + lastChar;
moveCursor = true;
continue;
} else {
//revert to the last known good value, increase index to break loop
val = KT_focusedEl.oldText;
i = mask.length;
}
break;
}
}
} else {
//if the current char is not inserted
if (val.length < KT_focusedEl.oldText.length) {
//deleted character
break;
}
for (;i<mask.length;i++) {
if (!KT_isSpecialChar(mask.charAt(i))) {
//re-enter the mask characters if it has been deleted
val += mask.charAt(i);
moveCursor = true;
} else {
break;
}
}
break;
}
}
if (val.length > mask.length) {
// strip trailing characters if text length is bigger than mask length
val = val.substr(0, mask.length);
moveCursor = true;
}
if (KT_focusedEl.value != val) {
KT_focusedEl.value = val; //last calculated correct value
}
KT_focusedEl.oldText = val; //update so we can check on next character
if (moveCursor) {
// no need to move the cursor, it is automatically moved at the end of the sellection by IE and Mozilla
}
}

/********** 
mask_parseFirstTime function
description:
Called from mask_onSetFocus, only the first time ( when obj.mask is undefined)
Tries to parse the initial value into a valid format, with the following algorithm:
- normalizes the string adding non special mask characters if they do not exist
- it strips the mask of all non special characters
- rebuilds the string using the stripped mask
- compares the string with the stripped mask and changes the values if they are invalid
- rebuild the string and returns
params:
none
returns:
none
**********/
function mask_parseFirstTime(value, mask) {
var strippedmask = ''; var strippedvalue = '';
cond = 1;imask = 0; ival = 0;cnt = 0;

//NORMALIZE VALUE: add non special characters
while (cond == 1) {
cond = 1;
if (!KT_isSpecialChar(mask.charAt(imask))) {
if (value.charCodeAt(ival).toString() != 'NaN') {
if (mask.charAt(imask) == value.charAt(ival)) {
imask++;ival++;
} else {
value = value.substr(0, ival) + mask.charAt(imask) + value.substr(ival, value.length);
imask = 0; ival = 0; cond = 1;
}
} else {
value += KT_maskDefaultValue(mask.charAt(imask));
}
} else {
imask++;ival++;
}
if (imask >= mask.length || ival >= value.length) {
cond = 0;
}
}

//save only the special chars in a mask
for (i=0;i<mask.length;i++) {
if (KT_isSpecialChar(mask.charAt(i))) {
strippedmask += mask.charAt(i);
if (value.charCodeAt(i).toString() != 'NaN') {
strippedvalue += value.charAt(i);
} else {
strippedvalue += KT_maskDefaultValue(mask.charAt(i));
}
}
}

oldvalue = value; //save the old value for reference
value = strippedvalue;
var newvalue = '';

//rebuild the string removing invalid values and replacing them with defaults
for (i=0;i<strippedmask.length;i++) {
if (!KT_validateSingle(value.charAt(i), strippedmask.charAt(i))) {
newvalue += KT_maskDefaultValue(strippedmask.charAt(i));
} else {
newvalue += value.charAt(i);
}
}

//rebuild the value,by adding the initial non special mask characters
var toret = ''; var j = 0; //j holds the index in the stripped mask
for (i=0;i<mask.length;i++) {
if (KT_isSpecialChar(mask.charAt(i))) {
toret += newvalue.charAt(j++);
} else {
toret += mask.charAt(i);
}
}
return toret;
}

/********** 
mask_onSetFocus function
description:
Called when the input gets the focus
Saved the current input in a global variable and also the current value
params:
none
returns:
none
**********/
function mask_onSetFocus(obj, mask) {
if ((typeof window.getSelection == 'undefined' && typeof document.selection == 'undefined')) {
// if the current browser is not compatible, do nothing
return;
}
if (typeof obj.mask == 'undefined') {
ret = '';
if (obj.value != '') {
ret = mask_parseFirstTime(obj.value, mask);
}
obj.value = ret;
obj.mask = mask;
}
KT_focusedEl = obj; // store the current input object in a global variable
if (typeof KT_focusedEl.oldText == 'undefined') {
KT_focusedEl.oldText = obj.value; // save the input current value
mask_onValueChanged(); // validates the current input value
}
}

/********** 
mask_onKillFocus function
description:
Called when the input loses the focus
Verifies the input's value
params:
none
returns:
none
**********/
function mask_onKillFocus() {
if ((typeof window.getSelection == 'undefined' && typeof document.selection == 'undefined')) {
// if the current browser is not compatible, do nothing
return;
}
mask_onValueChanged(); // validates the current input value
KT_focusedEl = null;
}