| blob | 2b28ff597ecc9d21ccc144cf1c27fa0845aded88 |
2 <root>
3 <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
6 <xsd:complexType>
9 <xsd:complexType>
10 <xsd:sequence>
12 </xsd:sequence>
17 </xsd:complexType>
18 </xsd:element>
20 <xsd:complexType>
23 </xsd:complexType>
24 </xsd:element>
26 <xsd:complexType>
27 <xsd:sequence>
30 </xsd:sequence>
35 </xsd:complexType>
36 </xsd:element>
38 <xsd:complexType>
39 <xsd:sequence>
41 </xsd:sequence>
43 </xsd:complexType>
44 </xsd:element>
45 </xsd:choice>
46 </xsd:complexType>
47 </xsd:element>
48 </xsd:schema>
51 </resheader>
54 </resheader>
56 <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
57 </resheader>
59 <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
60 </resheader>
62 <value><![CDATA[
63 function fValConfig()
64 {
65 /* Globals. Modify these to suit your setup
66 ------------------------------------------- */
68 // Attribute used for fValidate Validator codes
69 this.code = 'validators';
71 // Attribute used for custom error messages (override built-in error messages)
72 this.emsg = 'emsg';
74 // Attribute used for pattern with custom validator type
75 this.pattern = 'pattern';
77 // Change this to the classname you want for the error highlighting
78 this.errorClass = 'errHilite';
80 // If you wish fValidate to use only single classNames for errors
81 this.useSingleClassNames = false; // or true
83 // This is the even that triggers the clearing of the errorClass hilighting
84 this.clearEvent = 'change'; // 'change' | 'blur' | null
86 // For browsers that don't support attachEvent or addEventListere - override existing events for error reverting?
87 this.eventOverride = false;
89 // If the bConfirm flag is set to true, the users will be prompted with CONFIRM box with this message
90 // See your language file for this value
91 this.confirmMsg = fvalidate.i18n.config.confirmMsg;
93 // If user cancels CONFIRM, then this message will be alerted. If you don't want this alert to show, then
94 // empty the variable ( this.confirmAbortMsg = ''; )
95 // See your langauge file for this value
96 this.confirmAbortMsg = fvalidate.i18n.config.confirmAbortMsg;
98 // Enter the name/id of your form's submit button here. Can be a string or array of strings
99 this.submitButton = ['Submit','Submit2'];
101 // Enter the name/id of your form's reset button here
102 this.resetButton = 'Reset';
104 // Ender the name or id of the SELECT object here. Make sure you pay attention to the values (CC Types)
105 // used in the case statement for the function validateCC()
106 this.ccType = 'Credit_Card_Type';
108 // NOTE: The config value below exists for backwards compatibility with fValidate 3.55b. If you have a newer
109 // version, use the above this.ccType instead.
110 // Enter the DOM name of the SELECT object here. Make sure you pay attention to the values (CC Types)
111 // used in the case statement for the function validateCC()
112 this.ccTypeObj = 'form1.Credit_Card_Type';
114 // Element where box errors will appear
115 this.boxError = 'errors';
117 // Added by Ivan to allow for a heading in the box error mode
118 this.boxErrorHeadingClass = 'errorsHeading';
120 // Prefix given to all error paragraphs in box error mode
121 this.boxErrorPrefix = 'fv_error_';
123 this.displayName= 'displayName';
126 // Added by Ivan to designate a label to be an error label
127 this.errorSelectorCssClass = 'error';
128 }
129 ]]></value>
130 </data>
132 <value><![CDATA[
134 /***************************************************************************************************
135 *
137 * Version 5.01b
139 * www.peterbailey.net
140 * me@peterbailey.net
141 *
142 * IF YOU USE THIS SCRIPT, GIVE ME CREDIT PLEASE =)
143 *
144 * Visit http://www.peterbailey.net/fValidate/ for more info
145 *
146 * Feel free to contact me with any questions, comments, problems, or suggestions
147 *
148 * Note: This document most easily read with tab spacing set to 4
149 *
150 *******************************************************************************************************/
152 /* Create static fvalidate object
153 ------------------------------------------- */
154 if ( typeof fvalidate == 'undefined' )
155 {
156 var fvalidate = new Object();
157 }
159 /* Generic event handling
160 ------------------------------------------- */
161 fvalidate.addEvent = function( obj, evt, fn, useCapture )
162 {
163 if ( typeof obj.attachEvent != 'undefined' )
164 {
165 obj.attachEvent( "on" + evt, fn );
166 }
167 else if ( typeof obj.attachEventListener != 'undefined' )
168 {
169 obj.addEventListener( evt, fn, Boolean( useCapture ) );
170 }
171 }
172 fvalidate.addEvents = function( obj, evts, fn, useCapture )
173 {
174 var i = 0, evt;
175 while( evt = evts[i++] )
176 {
177 this.addEvent( obj, evt, fn, Boolean( useCapture ) );
178 }
179 }
181 /* Main validation routine
182 ------------------------------------------- */
183 function validateForm( f, bConfirm, bDisable, bDisableR, groupError, errorMode )
184 {
185 // Set defaults
186 bConfirm = Boolean( bConfirm );
187 bDisable = Boolean( bDisable );
188 bDisableR = Boolean( bDisableR );
189 groupError = Boolean( groupError );
192 // Init vars and fValidate object
193 var params, fvCode, type;
194 if ( typeof f.fv == 'undefined' )
195 {
196 f.fv = new fValidate( f, errorMode, groupError );
197 } else {
198 f.fv._reset();
199 f.fv.errorMode = errorMode;
200 }
202 // Loop through all form elements
203 var elem, i = 0, attr = f.fv.config.code;
204 while ( elem = f.elements[i++] )
205 {
206 // Skip fieldsets
207 if ( elem.nodeName == "FIELDSET" ) continue;
209 // Does element have validator attribute? (short-circuit check)
210 fvCode = ( elem[attr] ) ? elem[attr] : elem.getAttribute( attr );
211 if ( !( typeof fvCode == 'undefined' || fvCode == null || fvCode == "" ) )
212 {
213 // Set params, validation type, and validation state
214 params = fvCode.split( "|" );
215 type = params[0];
216 elem.validated = true;
218 // Valid validator type?
219 if ( typeof f.fv[type] == 'undefined' )
220 {
221 f.fv.devError( [type, elem.name], 'notFound' );
222 return false;
223 }
225 // Check for modifiers
226 switch( params.last() )
227 {
228 case 'bok' : // bok requested
230 elem.bok = true;
231 break;
232 case 'if' : // Conditional validation requested
234 elem._if_ = true;
235 break;
236 case 'then' : // Conditional validation requested
238 elem._then_ = true;
239 break;
240 default : // No modifiers
243 }
245 // Is element an array?
246 if ( /radio|checkbox/.test( elem.type ) )
247 {
248 // Set group property
249 elem.group = f.elements[elem.name];
250 }
252 // Add events if not already added
253 if ( typeof elem.fName == 'undefined' )
254 {
255 // If element is an array
256 if ( typeof elem.group != 'undefined' )
257 {
258 for ( var j = 0; j < elem.group.length; j++ )
259 {
260 // Apply event-function to each child
261 if ( f.fv.config.clearEvent != null )
262 {
263 // fvalidate.addEvent( elem.group.item( j ), fv.config.clearEvent, fv.revertError, false );
264 addEvent( elem.group.item( j ), f.fv.config.clearEvent, f.fv, 'revertError', false );
265 }
266 }
267 }
268 else
269 {
270 // Apply event-function to element
271 // fvalidate.addEvent( elem, fv.config.clearEvent, fv.revertError, false );
272 addEvent( elem, f.fv.config.clearEvent, f.fv, 'revertError', false );
273 }
274 }
276 // Set formatted name, current element
277 if ( elem.attributes[f.fv.config.displayName] != null)
278 {
279 elem.fName = elem.attributes[f.fv.config.displayName].value.format();
280 }
281 else
282 {
283 elem.fName = elem.name.format();
284 }
286 f.fv.elem = elem;
287 f.fv.type = type;
289 // Create function to call the proper validator method of the fValidate class
291 func( f.fv, type );
293 // If element test failed AND group error is off, return false
294 if ( elem.validated == false && groupError == false ) return false;
296 // Clear error if field okay
297 if ( elem.validated == true ) f.fv.revertError();
298 }
299 } // end of element loop
301 // If group error, show it
302 if ( groupError ) f.fv.showGroupError();
304 // Return false if errors found
307 // Show pre-submission confirmation
308 if ( bConfirm && !confirm( f.fv.config.confirmMsg ) )
309 {
310 if ( f.fv.config.confirmAbortMsg != '' ) alert( f.fv.config.confirmAbortMsg );
311 return false;
312 }
314 // Disable reset and/or submit buttons if requested
315 if ( bDisable )
316 {
317 if ( typeof f.fv.config.submitButton == 'object' )
318 {
319 var sb, j = 0;
320 while( sb = f.fv.config.submitButton[j++] )
321 {
322 if ( f.fv.elementExists( sb ) )
323 {
324 f.elements[sb].disabled = true;
325 }
326 }
327 }
328 else if ( f.fv.elementExists( f.fv.config.submitButton ) )
329 {
330 f.elements[f.fv.config.submitButton].disabled = true;
331 }
332 }
333 if ( bDisableR && f.fv.elementExists( f.fv.config.resetButton ) )
334 {
335 f.elements[f.fv.config.resetButton].disabled = true;
336 }
338 // Successful Validation. Submit form
339 return true;
341 function addEvent( elem, evt, obj, method, capture )
342 {
343 var self = elem;
344 if ( typeof elem.attachEvent != 'undefined' )
345 {
346 elem.attachEvent( "on" + evt, function() { obj[method]( self ) } );
347 }
348 else if ( typeof elem.addEventListener != 'undefined' )
349 {
350 elem.addEventListener( evt, function() { obj[method]( self ) }, capture );
351 }
352 else if ( f.fv.config.eventOverride )
353 {
354 eleme['on' + evt] = function() { obj[method]( self ) };
355 }
356 }
357 }
359 /* Constructor
360 ------------------------------------------- */
361 function fValidate( f, errorMode, groupError )
362 {
363 var self = this;
364 this.form = f;
365 this.errorMode = errorMode;
366 this.groupError = groupError;
367 this.errors = new Array();
368 this.validated = true;
369 this.config = new fValConfig();
370 this.i18n = fvalidate.i18n;
371 var selectorClass = this.config.errorSelectorCssClass;
372 // Add reset action to clear visual error cues
373 f.onreset = function()
374 {
375 var elem, i = 0;
376 while ( elem = this.elements[i++] )
377 {
378 self.revertError( elem );
379 }
380 }
382 addLabelProperties();
384 // Parses form and adds label properties to elements that have one specified
385 function addLabelProperties()
386 {
387 // Collect all label elements in form, init vars
388 if ( typeof f.getElementsByTagName == 'undefined' ) return;
389 var labels = f.getElementsByTagName( "label" );
390 var label, i = j = 0;
391 var elem;
392 // Loop through labels retrieved
393 while ( label = labels[i++] )
394 {
395 // For Opera 6
396 if ( typeof label.htmlFor == 'undefined' ) return;
398 // Skip the current element if the label is not for anything
399 if ( label.htmlFor == '') break;
401 // Retrieve element
402 elem = f.elements[label.htmlFor];
403 if ( typeof elem == 'undefined' )
404 { // No element found for label
405 self.devError( [label.htmlFor], 'noLabel' );
406 }
407 else if ( typeof elem.label != 'undefined' )
408 { // label property already added
409 continue;
410 }
412 { // For arrayed elements
413 for ( j = 0; j < elem.length; j++ )
414 {
415 elem.item( j ).label = label;
416 }
417 }
420 // Regular label
421 elem.label = label;
422 }
423 }
424 }
426 /* Reset for another validation
427 ------------------------------------------- */
428 fValidate.prototype._reset = function()
429 {
430 this.errors = new Array();
431 this.showErrors = new Array();
432 }
434 /* Checks if element exists in form
435 ------------------------------------------- */
436 fValidate.prototype.elementExists = function( elemName )
437 {
438 return Boolean( typeof this.form.elements[elemName] != 'undefined' );
439 }
441 /* Receives error message and determines action
442 ------------------------------------------- */
443 fValidate.prototype.throwError = function( args, which )
444 {
445 var elem = this.elem;
447 // Arrayed element?
448 if ( typeof elem.name == 'undefined' )
449 {
450 elem = elem[0];
451 }
453 // Bok requested AND element blank OR conditional validation?
454 if ( elem.bok && this.isBlank() )
455 { // skip
456 elem.validated = true;
457 return;
458 }
460 // Part of a conditional validation?
461 if ( elem.cv )
462 {
463 return;
464 }
466 // Set failsafe to false
467 elem.validated = false;
469 // Create error message
470 which = this.setArg( which, 0 );
471 args = this.setArg( args, [] );
472 emsgElem = ( typeof this.elem.getAttribute == "undefined" ) ?
473 this.elem[0]:
474 this.elem;
475 if ( emsgElem.getAttribute( this.config.emsg ) )
476 {
477 var error = emsgElem.getAttribute( this.config.emsg );
478 }
479 var error = this.translateMessage( args, this.i18n.errors[this.type][which] );
481 // Group error mode?
482 if ( this.groupError )
483 {
484 // Push error onto stack
485 this.errors.push( {'elem':elem, 'msg': error} );
486 }
487 else
488 {
489 // Process error message
490 this.showError( error, false, emsgElem );
492 var focusElem = ( typeof elem.fields != 'undefined' )?
493 elem.fields[0]:
494 elem;
496 // Focus and select elements, if possible
497 this.selectFocus( focusElem );
498 }
499 }
502 /* Shows error message to user
503 ------------------------------------------- */
504 fValidate.prototype.showError = function( emsg, last, elem )
505 {
506 // Set variables
507 var self = this,
508 elem = this.setArg( elem, this.elem ),
509 isHidden = Boolean( elem.type == 'hidden' ),
510 label = ( isHidden ) ? null : elem.label || null,
511 emsg = ( elem.getAttribute( this.config.emsg ) ) ? elem.getAttribute( this.config.emsg ).replace( /\\n/g, "\n" ) : emsg,
512 errorClass = this.config.errorClass,
513 singleCSS = this.config.useSingleClassNames,
514 selectorClass = this.config.errorSelectorCssClass;
516 if ( typeof this.showErrors == 'undefined' ) this.showErrors = new Array();
518 // Determine which error modes to use
519 switch( this.errorMode )
520 { // This represents all possible combinations
521 case 0 : alertError(); break;
522 case 1 : inputError(); break;
523 case 2 : labelError(); break;
524 case 3 : appendError(); break;
525 case 4 : boxError(); break;
526 case 5 : inputError(); labelError(); break;
527 case 6 : inputError(); appendError(); break;
528 case 7 : inputError(); boxError(); break;
529 case 8 : inputError(); alertError(); break;
530 case 9 : labelError(); appendError(); break;
531 case 10 : labelError(); boxError(); break;
532 case 11 : labelError(); alertError(); break;
533 case 12 : appendError(); boxError(); break;
534 case 13 : appendError(); alertError(); break;
535 case 14 : boxError(); alertError(); break;
536 case 15 : inputError(); labelError(); appendError(); break;
537 case 16 : inputError(); labelError(); boxError(); break;
538 case 17 : inputError(); labelError(); alertError(); break;
539 case 18 : inputError(); appendError(); boxError(); break;
540 case 19 : inputError(); appendError(); alertError(); break;
541 case 20 : inputError(); boxError(); alertError(); break;
542 case 21 : labelError(); appendError(); boxError(); break;
543 case 22 : labelError(); appendError(); alertError(); break;
544 case 23 : appendError(); boxError(); alertError(); break;
545 case 24 : inputError(); labelError(); appendError(); boxError(); break;
546 case 25 : inputError(); labelError(); appendError(); alertError(); break;
547 case 26 : inputError(); appendError(); boxError(); alertError(); break;
548 case 27 : labelError(); appendError(); boxError(); alertError(); break;
549 case 28 : inputError(); labelError(); appendError(); boxError(); alertError(); break;
550 }
551 // Regular alert error
552 function alertError()
553 {
554 if ( self.groupError ) self.showErrors.push( emsg );
555 else alert( emsg );
556 if ( last ) alert( self.i18n.groupAlert + self.showErrors.join( "\n\n- " ) );
557 }
558 // Applies class to form element
559 function inputError()
560 {
561 if ( ( typeof elem.length != 'undefined' && elem.length > 1 && elem.nodeName != 'SELECT' ) || isHidden )
562 {
563 var subelem, i = 0;
564 while( subelem = ( isHidden ) ? elem.fields[i++] : elem.item( i++ ) )
565 {
566 if ( subelem.className != '' && singleCSS )
567 {
568 subelem.revertClass = subelem.className;
569 subelem.className = errorClass;
570 } else {
571 self.addCSSClass( subelem, errorClass );
572 }
573 }
574 }
575 else
576 {
577 if ( singleCSS )
578 {
579 elem.revertClass = elem.className;
580 elem.className = errorClass;
581 } else {
582 self.addCSSClass( elem, errorClass );
583 }
584 }
585 }
586 // Applies class to element's label
587 function labelError()
588 {
589 if ( label == null ) return;
590 if ( self.config.useSingleClassNames )
591 {
592 label.className = errorClass;
593 } else {
594 self.addCSSClass( label, errorClass );
595 }
597 }
598 // Appends error message to element's label
599 function appendError()
600 {
601 if ( label == null || label.className.indexOf(selectorClass) == -1 ) return;
602 if ( typeof label.original == 'undefined' )
603 label.original = label.innerHTML;
604 label.innerHTML = label.original + emsg.toHTML();
605 }
606 // Appends Error message to pre-defined element
607 function boxError()
608 {
609 if ( typeof self.boxError == 'undefined' ) self.boxError = document.getElementById( self.config.boxError );
610 if ( self.boxError == null )
611 {
612 self.devError( [self.config.boxError], 'noBox' );
613 return;
614 }
615 if ( typeof self.elem.name == 'undefined' || self.elem.name == "" )
616 {
617 self.devError( [self.elem[self.config.code]], 'missingName' );
618 return;
619 }
620 var errorId = self.config.boxErrorPrefix + self.elem.name,
621 errorElem;
622 if ( errorElem = document.getElementById( errorId ) ) // short-circuit
623 {
624 errorElem.firstChild.innerHTML = emsg.toHTML();
625 }
626 else
627 {
628 errorElem = document.createHTMLElement( 'li', { id: errorId, 'innerHTML': emsg.toHTML(), title: self.i18n.boxToolTip } );
629 self.boxError.appendChild( errorElem );
630 errorElem.onclick = function()
631 {
632 var elem = self.form.elements[this.id.replace( self.config.boxErrorPrefix, "" )];
633 if ( typeof elem.fields != 'undefined' ) elem = elem.fields[0];
634 if ( typeof elem.select != 'undefined' ) elem.select();
635 if ( typeof elem.focus != 'undefined' ) elem.focus();
636 }
637 }
638 self.boxError.style.display = "block";
639 }
640 }
642 /* Handles element className manipulation
643 ------------------------------------------- */
644 fValidate.prototype.removeCSSClass = function( elem, className )
645 {
646 elem.className = elem.className.replace( className, "" ).trim();
647 }
648 fValidate.prototype.addCSSClass = function( elem, className )
649 {
650 this.removeCSSClass( elem, className );
651 elem.className = ( elem.className + " " + className ).trim();
652 }
654 /* Processes errors in stack for group error mode
655 ------------------------------------------- */
656 fValidate.prototype.showGroupError = function()
657 {
658 for ( var error, firstElem, i = 0; ( error = this.errors[i] ); i++ )
659 {
660 if ( i == 0 ) firstElem = error.elem;
661 this.elem = error.elem;
662 this.showError( error.msg, Boolean( i == ( this.errors.length - 1 ) ) );
663 }
664 if(firstElem){
665 var focusElem = ( typeof firstElem.fields != 'undefined' )?
666 firstElem.fields[0]:
667 firstElem;
668 this.selectFocus( focusElem );
669 }
670 }
672 /* Reverts any visible error notification upon event
673 ------------------------------------------- */
674 fValidate.prototype.revertError = function( elem )
675 {
676 elem = this.setArg( elem, this.elem );
677 var isHidden = Boolean( elem.type == 'hidden' ),
678 errorClass = this.config.errorClass,
679 i = 0,
680 errorElem,
681 subelem,
682 headingClass = this.config.boxErrorHeadingClass;
684 if ( ( typeof elem.length != 'undefined' && elem.length > 1 && elem.nodeName != 'SELECT' ) || isHidden )
685 {
686 if ( isHidden && typeof elem.fields != 'undefined' )
687 {
688 while( subelem = ( isHidden ) ? elem.fields[i++] : elem.item( i++ ) )
689 {
690 if ( typeof subelem.revertClass != 'undefined' )
691 {
692 subelem.className = subelem.revertClass;
693 }
694 }
695 }
696 } else {
697 if ( this.config.useSingleClassNames )
698 {
699 if ( typeof subElement.revertClass != 'undefined' )
700 {
701 elem.className = elem.revertClass;
702 }
703 } else {
704 this.removeCSSClass( elem, errorClass );
705 }
706 }
707 if ( typeof elem.label != 'undefined' )
708 {
709 if ( this.config.useSingleClassNames )
710 {
711 elem.label.className = '';
712 } else {
713 this.removeCSSClass( elem.label, errorClass );
714 }
715 elem.label.innerHTML = ( elem.label.original || elem.label.innerHTML );
716 }
717 if ( typeof this.boxError != 'undefined' )
718 {
719 if ( typeof this.boxError.normalize != 'undefined' ) this.boxError.normalize();
720 if ( errorElem = document.getElementById( this.config.boxErrorPrefix + elem.name ) )
721 {
722 this.boxError.removeChild( errorElem );
723 }
724 // Added by Ivan allow for a heading node to be in the error box.
725 var nodeCount = 0;
726 if(this.boxError.tagName.toUpperCase() == 'UL'){
729 var node = this.boxError.childNodes[i];
730 if(node.tagName && node.tagName == 'LI' && node.className != headingClass) nodeCount++;
731 }
732 if ( nodeCount == 0 ) this.boxError.style.display = 'none';
733 }
734 }
735 }
737 /* Focus and select elements, if possible
738 ------------------------------------------- */
739 fValidate.prototype.selectFocus = function( elem )
740 {
741 if ( typeof elem.select != 'undefined' ) elem.select();
742 if ( typeof elem.focus != 'undefined' ) elem.focus();
743 }
745 /* Developer assistance method - shows error if validator/element-type mismatch
746 ------------------------------------------- */
747 fValidate.prototype.typeMismatch = function()
748 {
749 var pats = {
750 'text': 'text|password|textarea',
751 'ta': 'textarea',
752 'hidden': 'hidden',
753 's1': 'select-one',
754 'sm': 'select-multiple',
755 'select': 'select-one|select-multiple',
756 'rg': 'radio',
757 'radio': 'radio',
758 'cb': 'checkbox',
759 'file': 'file'
760 };
761 var fail = false,
762 expected = new Array(),
763 result = key = type = regex = "";
764 for ( var i = 0; i < arguments.length; i++ )
765 {
766 type = pats[arguments[i]];
767 regex = new RegExp( type );
769 key += "0";
770 expected.push( type );
771 }
772 if ( key ^ result == 0 )
773 {
774 this.devError( [this.elem.fName, this.elem.type, expected.join( "|" ).replace( /\|/g, this.i18n.or )], 'mismatch' );
775 this.elem.validated = false;
776 return true;
777 }
778 return false;
779 }
781 /* Returns value(s) of reference element passed
782 ------------------------------------------- */
783 fValidate.prototype.getValue = function( elem )
784 {
785 switch ( elem.type )
786 {
787 case 'text' :
788 case 'password' :
789 case 'textarea' :
790 case 'hidden' :
791 case 'file' :
792 return elem.value;
793 case 'radio':
794 case 'select-single':
795 if ( typeof elem.length == 'undefined' )
796 {
797 return elem.value;
798 } else {
799 for ( var i = 0; i < elem.length; i++ )
800 {
802 if ( elem[i][choice] )
803 {
804 return elem[i].value;
805 }
806 }
807 }
808 case 'select-multiple' :
809 case 'checkbox' :
810 if ( typeof elem.length == 'undefined' )
811 {
812 return elem.value
813 } else {
814 var returnValues = new Array();
815 for ( var i = 0; i < elem.length; i++ )
816 {
818 if ( elem[i][choice] )
819 {
820 returnValues.push( elem[i].value );
821 }
822 }
823 return returnValues;
824 }
825 default: return null;
826 }
827 }
829 /* Generic argument setting method
830 ------------------------------------------- */
831 fValidate.prototype.setArg = function( arg, def )
832 {
833 return ( typeof arg == 'undefined' || arg == '' || arg == null ) ? def : arg;
834 }
836 /* Blank checker. Optional string argument for evaluating element other than current
837 ------------------------------------------- */
838 fValidate.prototype.isBlank = function( el )
839 {
840 var elem = this.form.elements[el] || this.elem;
841 return Boolean( /^\s*$/.test( elem.value ) );
842 }
844 /* Translates messages using language file
845 ------------------------------------------- */
846 fValidate.prototype.translateMessage = function( args, format )
847 {
848 var msg = ""
849 for ( var i = 0; i < format.length; i++ )
850 {
851 msg += ( typeof format[i] == 'number' ) ? args[format[i]] : format[i];
852 }
853 return msg;
854 }
856 /* Throws developer errors
857 ------------------------------------------- */
858 fValidate.prototype.devError = function( args, which )
859 {
860 if ( typeof args == 'string' )
861 {
862 which = args;
863 args = [];
864 }
865 which = this.setArg( which, this.type );
866 var format = this.i18n.devErrors[which];
867 var a = [
868 this.i18n.devErrors.lines[0],
869 '----------------------------------------------------------------------------------------------',
870 this.translateMessage( args, format ),
871 '----------------------------------------------------------------------------------------------',
872 this.i18n.devErrors.lines[1]
873 ];
874 alert( a.join( "\n" ) );
875 }
877 /* Throws specific developer error
878 ------------------------------------------- */
879 fValidate.prototype.paramError = function( param, elemName )
880 {
881 elemName = this.setArg( elemName, this.elem.name );
882 this.devError( [param, this.type, elemName], 'paramError' );
883 }
884 /* Non-fValidate methods *****************************************/
886 /* For easy creation of DOM nodes
887 ------------------------------------------- */
888 document.createHTMLElement = function( elemName, attribs )
889 {
890 if ( typeof document.createElement == 'undefined' ) return;
891 var elem = document.createElement( elemName );
892 if ( typeof attribs != 'undefined' )
893 {
894 for ( var i in attribs )
895 {
896 switch ( true )
897 {
898 case ( i == 'text' ) : elem.appendChild( document.createTextNode( attribs[i] ) ); break;
899 case ( i == 'class' ) : elem.className = attribs[i]; break;
900 default : elem.setAttribute( i, '' ); elem[i] = attribs[i];
901 }
902 }
903 }
904 return elem;
905 }
907 /* Trims b items from the beginning of the array, e items from the end
908 ------------------------------------------- */
909 Array.prototype.slicex = function( b, e )
910 {
911 var a = new Array();
912 var count = 0;
913 for ( var i = b; i < this.length - e; i++ )
914 {
915 a[count++] = this[i];
916 }
917 return a;
918 }
920 /* Returns array as argument-compatible string
921 ------------------------------------------- */
922 Array.prototype.toArgString = function()
923 {
924 var a = new Array();
925 for ( var i = 0; i < this.length; i++ )
926 {
928 }
929 return a.toString();
930 }
932 /* Prototype push if missing
933 ------------------------------------------- */
934 if ( typeof Array.prototype.push == 'undefined' )
935 {
936 Array.prototype.push = function()
937 {
938 for ( var i = 0; i < arguments.length; i++ )
939 {
940 this[this.length] = arguments[i];
941 }
942 }
943 }
945 /* Returns last item of the array
946 ------------------------------------------- */
947 Array.prototype.last = function()
948 {
949 return this[this.length-1];
950 }
952 /* Removes the follow charaters _[] from an elements name for human-reading
953 ------------------------------------------- */
954 String.prototype.format = function()
955 {
957 }
959 /* Replaces newline characters with XHTML BR tags
960 ------------------------------------------- */
961 String.prototype.toHTML = function()
962 {
964 }
966 /* Trims leading and trailing whitespace from string
967 ------------------------------------------- */
968 String.prototype.trim = function()
969 {
970 return this.replace( /^\s+|\s+$/, "" );
971 }
973 /* Escapes necessary charactes for string-generated regular expressions
974 ------------------------------------------- */
975 String.prototype.toPattern = function()
976 {
978 }
981 ]]></value>
982 </data>
984 <value><![CDATA[
985 /*< blank basic *******************************************************************/
986 fValidate.prototype.blank = function()
987 {
988 if ( this.typeMismatch( 'text' ) ) return;
989 if ( this.isBlank() )
990 {
991 this.throwError( [this.elem.fName] );
992 }
993 }
994 /*/>*/
995 /*< number numbers *******************************************************************/
996 fValidate.prototype.number = function( type, lb, ub )
997 {
998 if ( this.typeMismatch( 'text' ) ) return;
1000 lb = this.setArg( lb, 0 );
1001 ub = this.setArg( ub, Number.infinity );
1002 if ( lb > ub )
1003 {
1004 this.devError( [lb, ub, this.elem.name] );
1005 return;
1006 }
1007 var fail = Boolean( isNaN( num ) || num != this.elem.value );
1008 if ( !fail )
1009 {
1010 switch( true )
1011 {
1012 case ( lb != false && ub != false ) : fail = !Boolean( lb <= num && num <= ub ); break;
1013 case ( lb != false ) : fail = Boolean( num < lb ); break;
1014 case ( ub != false ) : fail = Boolean( num > ub ); break;
1015 }
1016 }
1017 if ( fail )
1018 {
1019 this.throwError( [this.elem.fName] );
1020 return;
1021 }
1022 this.elemPass = true;
1023 }
1024 /*/>*/
1025 /*< numeric numbers *******************************************************************/
1026 fValidate.prototype.numeric = function( len )
1027 {
1028 if ( this.typeMismatch( 'text' ) ) return;
1029 len = this.setArg( len, '*' );
1030 var regex = new RegExp( ( len == '*' ) ? "^\\d+$" : "^\\d{" + parseInt( len, 10 ) + "}\\d*$" );
1031 if ( !regex.test( this.elem.value ) )
1032 {
1033 if ( len == "*" )
1034 {
1035 this.throwError( [this.elem.fName] );
1036 } else {
1037 this.throwError( [len, this.elem.fName], 1 );
1038 }
1039 }
1040 }
1041 /*/>*/
1042 /*< length basic *******************************************************************/
1043 fValidate.prototype.length = function( len, maxLen )
1044 {
1045 if ( this.typeMismatch( 'text' ) ) return;
1046 var vlen = this.elem.value.length;
1047 len = Math.abs( len );
1048 maxLen = Math.abs( this.setArg( maxLen, Number.infinity ) );
1049 if ( len > maxLen )
1050 {
1051 this.devError( [len, maxLen, this.elem.name] );
1052 return;
1053 }
1055 {
1056 this.throwError( [this.elem.fName, len] );
1057 }
1058 if ( vlen > maxLen )
1059 {
1060 this.throwError( [this.elem.fName, maxLen, vlen], 1 );
1061 }
1062 }
1063 /*/>*/
1064 /*< alnum extended *******************************************************************/
1065 fValidate.prototype.alnum = function( minLen, tCase, numbers, spaces, puncs )
1066 {
1067 if ( this.typeMismatch( 'text' ) ) return;
1069 tCase = this.setArg( tCase, "a" );
1071 //alert( [minLen,tCase,numbers,spaces,puncs] );
1076 //alert( [minLen,tCase,numbers,spaces,puncs] );
1078 var okChars = "",
1079 arrE = ['None','Any','No','No','Any'];
1081 if ( minLen != '*' )
1082 {
1083 minLen = parseInt( minLen, 10 );
1084 arrE[0] = minLen;
1085 } else {
1086 minLen = 0;
1087 }
1089 switch( tCase.toUpperCase() )
1090 {
1091 case 'U':
1092 okChars += 'A-Z';
1093 arrE[1] = 'UPPER';
1094 break;
1095 case 'L':
1096 okChars += 'a-z';
1097 arrE[1] = 'lower';
1098 break;
1099 case 'C':
1100 okChars += 'A-Z][a-z';
1101 arrE[1] = 'Intial capital';
1102 minLen--;
1103 break;
1104 default:
1105 okChars += 'a-zA-Z';
1106 break;
1107 }
1109 if ( numbers == true )
1110 {
1112 arrE[2] = 'Yes';
1113 }
1114 if ( spaces == true )
1115 {
1116 okChars += ' ';
1117 arrE[3] = 'Yes';
1118 }
1119 if ( puncs == "any" )
1120 {
1122 }
1123 else if ( puncs == "none" )
1124 {
1126 }
1127 else
1128 {
1129 puncs = puncs.replace( /pipe/g, "|" );
1130 okChars += puncs;
1132 }
1133 var length = ( minLen != "*" )?
1135 "+";
1136 var regex = ( puncs == "any" ) ?
1140 if ( !regex.test( this.elem.value ) )
1141 {
1142 this.throwError( [this.elem.value, this.elem.fName, arrE[0], arrE[1], arrE[2], arrE[3], arrE[4]] );
1143 }
1144 }
1145 /*/>*/
1146 /*< equalto logical *******************************************************************/
1147 fValidate.prototype.equalto = function( oName )
1148 {
1149 if ( this.typeMismatch( 'text' ) ) return;
1150 if ( typeof oName == 'undefined' )
1151 {
1152 this.paramError( 'oName' );
1153 }
1154 var otherElem = this.form.elements[oName];
1155 if ( this.elem.value != otherElem.value )
1156 {
1157 this.throwError( [this.elem.fName,otherElem.fName] );
1158 }
1159 }
1160 /*/>*/
1161 /*< ssn extended *******************************************************************/
1162 fValidate.prototype.ssn = function()
1163 {
1164 if ( this.typeMismatch( 'text' ) ) return;
1166 this.throwError();
1167 }
1168 /*/>*/
1169 /*< select controls *******************************************************************/
1170 fValidate.prototype.select = function()
1171 {
1172 if ( this.typeMismatch( 's1' ) ) return;
1173 if ( this.elem.selectedIndex == 0 )
1174 {
1175 this.throwError( [this.elem.fName] );
1176 }
1177 }
1178 /*/>*/
1179 /*< selectm controls *******************************************************************/
1180 fValidate.prototype.selectm = function( minS, maxS )
1181 {
1182 if ( this.typeMismatch( 'sm' ) ) return;
1183 if ( typeof minS == 'undefined' )
1184 {
1185 this.paramError( 'minS' );
1186 }
1187 if ( maxS == 999 || maxS == '*' || typeof maxS == 'undefined' || maxS > this.elem.length ) maxS = this.elem.length;
1189 var count = 0;
1190 for ( var opt, i = 0; ( opt = this.elem.options[i] ); i++ )
1191 {
1192 if ( opt.selected ) count++;
1193 }
1195 if ( count < minS || count > maxS )
1196 {
1197 this.throwError( [minS, maxS, this.elem.fName, count] );
1198 }
1199 }
1200 /*/>*/
1201 /*< selecti controls *******************************************************************/
1202 fValidate.prototype.selecti = function( indexes )
1203 {
1205 if ( this.typeMismatch( 's1' ) ) return;
1206 if ( typeof indexes == 'undefined' )
1207 {
1208 this.paramError( 'indexes' );
1209 return;
1210 }
1211 indexes = indexes.split( "," );
1212 var selectOK = true;
1214 for ( var i = 0; i < indexes.length; i++ )
1215 {
1216 if ( this.elem.options[indexes[i]].selected )
1217 {
1218 selectOK = false;
1219 break;
1220 }
1221 }
1222 if ( !selectOK )
1223 {
1224 this.throwError( [this.elem.fName] );
1225 }
1226 }
1227 /*/>*/
1228 /*< cazip international *******************************************************************/
1229 fValidate.prototype.cazip = function()
1230 {
1231 var elem = this.elem;
1232 if ( this.typeMismatch( 'text' ) ) return;
1233 elem.value = elem.value.toUpperCase();
1235 {
1236 this.throwError();
1237 }
1238 }
1239 fValidate.prototype.capost = fValidate.prototype.cazip;
1240 /*/>*/
1241 /*< ukpost international *******************************************************************/
1242 fValidate.prototype.ukpost = function()
1243 {
1244 var elem = this.elem;
1245 if ( this.typeMismatch( 'text' ) ) return;
1246 elem.value = elem.value.toUpperCase();
1248 {
1249 this.throwError();
1250 }
1251 }
1252 /*/>*/
1253 /*< germanpost international *******************************************************************/
1254 fValidate.prototype.germanpost = function()
1255 {
1256 var elem = this.elem;
1257 if ( this.typeMismatch( 'text' ) ) return;
1258 elem.value = elem.value.toUpperCase();
1259 if ( !( /^(?:CH\-)\d{4}$/.test( elem.value ) ) )
1260 {
1261 this.throwError();
1262 }
1263 }
1264 /*/>*/
1265 /*< swisspost international *******************************************************************/
1266 fValidate.prototype.swisspost = function()
1267 {
1268 var elem = this.elem;
1269 if ( this.typeMismatch( 'text' ) ) return;
1270 elem.value = elem.value.toUpperCase();
1271 if ( !( /^(?:D\-)\d{5}$/.test( this.elem.value ) ) )
1272 {
1273 this.throwError();
1274 }
1275 }
1276 /*/>*/
1277 /*< email web *******************************************************************/
1278 fValidate.prototype.email = function( level )
1279 {
1280 if ( this.typeMismatch( 'text' ) ) return;
1281 if ( typeof level == 'undefined' ) level = 0;
1282 var emailPatterns = [
1283 /.+@.+\..+$/i,
1284 /^\w.+@\w.+\.[a-z]+$/i,
1285 /^\w[-_a-z~.]+@\w[-_a-z~.]+\.[a-z]{2}[a-z]*$/i,
1287 ];
1288 if ( ! emailPatterns[level].test( this.elem.value ) )
1289 {
1290 this.throwError();
1291 }
1292 }
1293 /*/>*/
1294 /*< url web *******************************************************************/
1295 fValidate.prototype.url = function( hosts, hostOptional, allowQS )
1296 {
1297 if ( this.typeMismatch( 'text' ) ) return;
1299 this.setArg( hosts, "http" );
1304 if ( Boolean( hostOptional ) == true ) front += "?";
1305 var regex = new RegExp( front + "([\\w\\d-]+\\.?)+" + end );
1307 if ( !regex.test( this.elem.value ) )
1308 {
1309 this.throwError( [this.elem.fName] );
1310 }
1311 }
1312 /*/>*/
1313 /*< ip web *******************************************************************/
1314 fValidate.prototype.ip = function( portMin, portMax )
1315 {
1316 if ( this.typeMismatch( 'text' ) ) return;
1317 portMin = this.setArg( portMin, 0 );
1318 portMax = this.setArg( portMax, 99999 );
1320 {
1321 this.throwError();
1322 }
1323 else
1324 {
1325 var part, i = 0, parts = this.elem.value.split( /[.:]/ );
1326 while ( part = parts[i++] )
1327 {
1328 if ( i == 5 ) // Check port
1329 {
1330 if ( part < portMin || part > portMax )
1331 {
1332 this.throwError( [part, portMin, portMax], 1 );
1333 }
1334 }
1336 {
1337 this.throwError();
1338 }
1339 }
1340 }
1341 }
1342 /*/>*/
1343 /*< decimal numbers *******************************************************************/
1344 fValidate.prototype.decimal = function( lval, rval )
1345 {
1346 if ( this.typeMismatch( 'text' ) ) return;
1347 var regex = '', elem = this.elem;
1348 if ( lval != '*' ) lval = parseInt( lval, 10 );
1349 if ( rval != '*' ) rval = parseInt( rval, 10 );
1351 if ( lval == 0 )
1353 else if ( lval == '*' )
1355 else if ( rval == '*' )
1357 else
1360 regex = new RegExp( regex );
1362 if ( !regex.test( elem.value ) )
1363 {
1364 this.throwError( [elem.value,elem.fName] );
1365 }
1366 }
1367 /*/>*/
1368 /*< decimalr numbers *******************************************************************/
1369 fValidate.prototype.decimalr = function( lmin, lmax, rmin, rmax )
1370 {
1371 if ( this.typeMismatch( 'text' ) ) return;
1373 lmax = ( lmax == '*' )? '': parseInt( lmax, 10 );
1375 rmax = ( rmax == '*' )? '': parseInt( rmax, 10 );
1377 var regex = new RegExp(decReg);
1378 if ( !regex.test( this.elem.value ) )
1379 {
1380 this.throwError( [this.elem.fName] );
1381 }
1382 return true;
1383 }
1384 /*/>*/
1385 /*< zip extended *******************************************************************/
1386 fValidate.prototype.zip = function( sep )
1387 {
1388 if ( this.typeMismatch( 'text' ) ) return;
1389 sep = this.setArg( sep, "- " );
1391 if ( ! regex.test( this.elem.value ) )
1392 {
1393 this.throwError();
1394 }
1395 }
1396 /*/>*/
1397 /*< phone extended *******************************************************************/
1398 fValidate.prototype.phone = function( format )
1399 {
1400 if ( this.typeMismatch( 'text' ) ) return;
1401 format = this.setArg( format, 0 );
1402 var patterns = [
1403 /^(\(?\d\d\d\)?)?[ -]?\d\d\d[ -]?\d\d\d\d$/, // loose
1404 /^(\(\d\d\d\) )?\d\d\d[ -]\d\d\d\d$/ // strict
1405 ];
1406 if ( !patterns[format].test( this.elem.value ) )
1407 {
1408 if ( format == 1 )
1409 {
1410 this.throwError();
1411 } else {
1412 this.throwError( [], 1 );
1413 }
1414 }
1415 }
1416 /*/>*/
1417 /*< date datetime *******************************************************************/
1418 fValidate.prototype.date = function( formatStr, delim, code, specDate )
1419 {
1420 if ( this.typeMismatch( 'text' ) ) return;
1421 if ( typeof formatStr == 'undefined' )
1422 {
1423 this.paramError( 'formatStr' );
1424 return;
1425 }
1427 delim = this.setArg( delim, "/" );
1429 var error = [this.elem.fName, formatStr.replace( /\//g, delim )];
1430 var format = formatStr.split( "/" );
1431 var compare = this.elem.value.split( delim );
1432 var order = new Object();
1434 for ( var i = 0; i < format.length; i++ )
1435 {
1436 switch( format[i].charAt( 0 ).toLowerCase() )
1437 {
1438 case 'm' :
1439 order.months = i;
1440 break;
1441 case 'd' :
1442 order.days = i;
1443 break;
1444 case 'y' :
1445 order.years = i;
1446 break;
1447 }
1448 }
1449 var thisDate = new Date( compare[order.years], compare[order.months]-1, compare[order.days] );
1451 if ( isNaN( thisDate ) || thisDate.getDate() != compare[order.days] || thisDate.getMonth() != compare[order.months]-1 || thisDate.getFullYear().toString().length != formatStr.match( /y/g ).length )
1452 {
1453 this.throwError( error );
1454 return;
1455 }
1457 var compareElem = this.form.elements[specDate];
1458 if ( typeof compareElem != 'undefined' )
1459 {
1460 specDate = compareElem.validDate || compareElem.value;
1461 }
1462 var compareDate = ( specDate == 'today' )?
1463 new Date():
1464 new Date( specDate );
1465 compareDate.setHours(0);
1466 compareDate.setMinutes(0);
1467 compareDate.setSeconds(0);
1468 compareDate.setMilliseconds(0);
1470 var timeDiff = compareDate.getTime() - thisDate.getTime();
1471 var dateOk = false;
1473 switch ( parseInt( code ) ) {
1474 case 1 : // Before specDate
1476 error = 1;
1477 break;
1478 case 2 : // Before or on specDate
1480 error = 2;
1481 break;
1482 case 3 : // After specDate
1483 dateOk = Boolean( timeDiff < 0 );
1484 error = 3;
1485 break;
1486 case 4 : // After or on specDate
1488 error = 4;
1489 break;
1490 default : dateOk = true;
1491 }
1492 if ( !dateOk )
1493 {
1494 this.throwError( [specDate], error );
1495 }
1496 this.elem.validDate = thisDate.toString();
1497 }
1498 /*/>*/
1499 /*< money ecommerce *******************************************************************/
1500 fValidate.prototype.money = function( ds, grp, dml )
1501 {
1502 if ( this.typeMismatch( 'text' ) ) return;
1504 ds = ( ds == ' ' ) ? false : ds.toPattern();
1505 grp = ( grp == ' ' ) ? false : grp.toPattern();
1506 dml = ( dml == ' ' ) ? false : dml.toPattern();
1508 var moneySyntax, pattern;
1510 switch( true )
1511 {
1512 case Boolean( ds && grp && dml ): // Dollar sign, grouping, and decimal
1513 pattern = "^" + ds + "(?:(?:[0-9]{1,3}" + grp + ")(?:[0-9]{3}" + grp + ")*[0-9]{3}|[0-9]{1,3})(" + dml + "[0-9]{2})$";
1515 break;
1516 case Boolean( ds && grp && !dml ): // Dollar sign and grouping
1517 pattern = "^" + ds + "(?:(?:[0-9]{1,3}" + grp + ")(?:[0-9]{3}" + grp + ")*[0-9]{3}|[0-9]{1,3})$";
1519 break;
1520 case Boolean( ds && !grp && dml ): // Dollar sign and decimal
1523 break;
1524 case Boolean( !ds && grp && dml ): // Grouping and decimal
1525 pattern ="^(?:(?:[0-9]{1,3}" + grp + ")(?:[0-9]{3}" + grp + ")*[0-9]{3}|[0-9]{1,3})(" + dml + "[0-9]{2})?$";
1527 break;
1528 case Boolean( ds && !grp && !dml ): // Dollar sign only
1531 break;
1532 case Boolean( !ds && grp && !dml ): // Grouping only
1535 break;
1536 case Boolean( !ds && !grp && dml ): // Decimal only
1539 break;
1540 case Boolean( !ds && !grp && !dml ): // No params set, all special chars become optional
1541 pattern ="^.?(?:(?:[0-9]{1,3}.?)(?:[0-9]{3}.?)*[0-9]{3}|[0-9]{1,3})(.[0-9]{2})?$";
1542 moneySyntax ="[?]XX[?]XXX[?XX]";
1543 }
1545 var regex = new RegExp( pattern );
1546 if ( !regex.test( this.elem.value ) )
1547 {
1548 this.throwError( [this.elem.fName, moneySyntax.replace( /\\/g, '' )] );
1549 }
1550 }
1551 /*/>*/
1552 /*< checkbox controls *******************************************************************/
1553 fValidate.prototype.checkbox = function( minC, maxC )
1554 {
1555 if ( this.typeMismatch( 'cb' ) ) return;
1556 if ( typeof minC == 'undefined' )
1557 {
1558 this.paramError( 'minC' );
1559 return;
1560 }
1561 if ( this.elem == this.form.elements[this.elem.name] && !this.elem.checked )
1562 {
1563 this.throwError( [this.elem.fName] );
1564 }
1565 else
1566 {
1567 this.elem = this.form.elements[this.elem.name];
1568 var len = this.elem.length;
1569 var count = 0;
1572 {
1573 maxC == len;
1574 }
1575 var i = len;
1577 {
1578 if ( this.elem[i].checked )
1579 {
1580 count++;
1581 }
1582 }
1583 if ( count < minC || count > maxC )
1584 {
1585 this.throwError( [minC, maxC, this.elem[0].fName, count] );
1586 }
1587 }
1588 }
1589 /*/>*/
1590 /*< radio controls *******************************************************************/
1591 fValidate.prototype.radio = function()
1592 {
1593 if ( this.typeMismatch( 'rg' ) ) return;
1594 if ( this.elem == this.form.elements[this.elem.name] && !this.elem.checked )
1595 {
1596 this.throwError( [this.elem.fName] );
1597 }
1598 else
1599 {
1600 this.elem = this.form.elements[this.elem.name];
1602 for ( var i = 0; i < this.elem.length; i++ )
1603 {
1604 if ( this.elem.item( i ).checked )
1605 {
1606 return;
1607 }
1608 }
1609 this.throwError( [this.elem[0].fName] );
1610 }
1611 }
1612 /*/>*/
1613 /*< eitheror logical *******************************************************************/
1614 fValidate.prototype.eitheror = function()
1615 {
1616 if ( this.typeMismatch( 'hidden' ) ) return;
1617 if ( typeof arguments[0] == 'undefined' )
1618 {
1619 this.paramError( 'delim' );
1620 return;
1621 }
1622 if ( typeof arguments[1] == 'undefined' )
1623 {
1624 this.paramError( 'fields' );
1625 return;
1626 }
1627 var arg, i = 0,
1628 fields = new Array(),
1629 field,
1630 nbCount = 0,
1633 this.elem.fields = new Array();
1635 while ( arg = args[i++] )
1636 {
1637 field = this.form.elements[arg];
1638 fields.push( field.fName );
1639 this.elem.fields.push( field );
1641 if ( !this.isBlank( arg ) )
1642 {
1643 nbCount++;
1644 }
1645 }
1646 if ( nbCount != 1 )
1647 {
1648 this.throwError( [fields.join( "\n\t-" )] );
1649 }
1650 }
1651 /*/>*/
1652 /*< atleast logical *******************************************************************/
1653 fValidate.prototype.atleast = function()
1654 {
1655 if ( this.typeMismatch( 'hidden' ) ) return;
1656 if ( typeof arguments[0] == undefined )
1657 {
1658 this.paramError( 'qty' );
1659 return;
1660 }
1661 if ( typeof arguments[1] == undefined )
1662 {
1663 this.paramError( 'delim' );
1664 return;
1665 }
1666 if ( typeof arguments[2] == undefined )
1667 {
1668 this.paramError( 'fields' );
1669 return;
1670 }
1671 var arg, i = 0,
1672 fields = new Array(),
1673 field,
1674 nbCount = 0,
1677 this.elem.fields = new Array();
1679 while ( arg = args[i++] )
1680 {
1681 field = this.form.elements[arg];
1682 fields.push( field.fName );
1683 this.elem.fields.push( field );
1685 if ( !this.isBlank( arg ) )
1686 {
1687 nbCount++;
1688 }
1689 }
1690 if ( nbCount < arguments[0] )
1691 {
1693 }
1694 }
1695 /*/>*/
1696 /*< allornone logical *******************************************************************/
1697 fValidate.prototype.allornone = function()
1698 {
1699 if ( this.typeMismatch( 'hidden' ) ) return;
1700 if ( typeof arguments[0] == 'undefined' )
1701 {
1702 this.paramError( 'delim' );
1703 return;
1704 }
1705 if ( typeof arguments[1] == 'undefined' )
1706 {
1707 this.paramError( 'fields' );
1708 return;
1709 }
1710 var arg, i = 0,
1711 fields = new Array(),
1712 field,
1713 nbCount = 0,
1716 this.elem.fields = new Array();
1718 while ( arg = args[i++] )
1719 {
1720 field = this.form.elements[arg];
1721 fields.push( field.fName );
1722 this.elem.fields.push( field );
1724 if ( !this.isBlank( arg ) )
1725 {
1726 nbCount++;
1727 }
1728 }
1730 {
1731 this.throwError( [fields.join( "\n\t-" ), nbCount] );
1732 }
1733 }
1734 /*/>*/
1735 /*< comparison logical *******************************************************************/
1736 fValidate.prototype.comparison = function( field1, operator, field2 )
1737 {
1738 if ( this.typeMismatch( 'hidden' ) ) return;
1739 var elem1 = this.form.elements[field1],
1740 elem2 = this.form.elements[field2],
1741 value1 = this.getValue( elem1 ),
1742 value2 = this.getValue( elem2 );
1743 i18n = this.i18n.comparison;
1744 i = -1;
1746 var operators =
1747 [
1748 ['>', i18n.gt],
1749 ['<', i18n.lt],
1750 ['>=', i18n.gte],
1751 ['<=', i18n.lte],
1752 ['==', i18n.eq],
1753 ['!=', i18n.neq]
1754 ];
1755 while( operators[++i][0] != operator ){ }
1756 this.elem.fields = [elem1, elem2];
1757 if ( ! eval( value1 + operator + value2 ) )
1758 {
1759 this.throwError( [elem1.fName, operators[i][1], elem2.fName] );
1760 }
1761 }
1762 /*/>*/
1763 /*< file controls *******************************************************************/
1764 fValidate.prototype.file = function( extensions, cSens )
1765 {
1766 if ( this.typeMismatch( 'file' ) ) return;
1767 if ( typeof extensions == 'undefined' )
1768 {
1769 this.paramError( 'extensions' );
1770 return;
1771 }
1774 if ( ! regex.test( this.elem.value ) )
1775 {
1776 this.throwError( [extensions.replace( /,/g, "\n" )] );
1777 }
1778 }
1779 /*/>*/
1780 /*< custom special *******************************************************************/
1781 fValidate.prototype.custom = function( flags, reverseTest )
1782 {
1783 if ( this.typeMismatch( 'text' ) ) return;
1784 flags = ( flags ) ? flags.replace( /[^gim]/ig ) : "";
1785 var regex = new RegExp( this.elem.getAttribute( this.config.pattern ), flags );
1786 if ( !regex.test( this.elem.value ) )
1787 {
1788 this.throwError( [this.elem.fName] );
1789 }
1790 }
1791 /*/>*/
1792 /*< cc ecommerce *******************************************************************/
1793 fValidate.prototype.cc = function()
1794 {
1795 if ( this.typeMismatch( 'text' ) ) return;
1796 var typeElem = this.form.elements[this.config.ccType];
1798 if ( !typeElem )
1799 {
1800 this.devError( 'noCCType' )
1801 return;
1802 }
1803 var ccType = typeElem.options[typeElem.selectedIndex].value.toUpperCase();
1805 var types = {
1813 'SWITCH' : /^(49030[2-9]|49033[5-9]|49110[1-2]|4911(7[4-9]|8[1-2])|4936[0-9]{2}|564182|6333[0-4][0-9]|6759[0-9]{2})\d{10}(\d{2,3})?$/,
1814 'DELTA' : /^4(1373[3-7]|462[0-9]{2}|5397[8|9]|54313|5443[2-5]|54742|567(2[5-9]|3[0-9]|4[0-5])|658[3-7][0-9]|659(0[1-9]|[1-4][0-9]|50)|844[09|10]|909[6-7][0-9]|9218[1|2]|98824)\d{10}$/,
1816 };
1817 if ( typeElem.validated == false && this.groupError == true ) return;
1818 if ( typeof types[ccType] == 'undefined' && typeElem.validated == false && this.groupError == false )
1819 {
1820 this.devError( [ccType] );
1821 return;
1822 }
1823 this.elem.value = this.elem.value.replace( /[^\d]/g, "" );
1824 if ( !types[ccType].test( this.elem.value ) || !this.elem.value.luhn() )
1825 {
1826 this.throwError( [this.elem.fName] );
1827 }
1828 }
1830 String.prototype.luhn = function()
1831 {
1832 var i = this.length;
1833 var checkSum = "", digit;
1834 while ( digit = this.charAt( --i ) )
1835 {
1837 }
1838 checkSum = eval( checkSum.split('').join('+') );
1840 }
1841 /*/>*/
1842 /*< ccDate ecommerce *******************************************************************/
1843 fValidate.prototype.ccDate = function( month, year )
1844 {
1845 if ( this.typeMismatch( 's1' ) ) return;
1847 month = parseInt( this.getValue( this.form.elements[month] ), 10 );
1849 var today = new Date();
1850 var expDate = new Date( year, month )
1852 if ( expDate < today )
1853 {
1855 }
1856 }
1857 /*/>*/
1858 ]]></value>
1859 </data>
1861 </root>