// ------------------------------------------------------------------------------ // European Molecular Biology Laboratory // European Bioinformatic Institute // Functional Genomics // ------------------------------------------------------------------------------ // // Description: // This is a general set of JavaScript functions for validating input on // an HTML form. // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // // // Many of the below functions take an optional parameter eok (for "emptyOK") // which determines whether the empty string will return true or false. // Default behavior is controlled by global variable defaultEmptyOK. // // |============================================================================================================= // | // | FUNCTION LIST BOX // | // |------------------------------------------------------------------------------------------------------------- // | BASIC DATA VALIDATION FUNCTIONS: // |------------------------------------------------------------------------------------------------------------- // | isEmpty (s) Check whether string s is empty. // | isWhitespace (s) Check whether string s is empty or whitespace. // | isLetter (c) Check whether character c is an English letter // | isDigit (c) Check whether character c is a digit // | isLetterOrDigit (c) Check whether character c is a letter or digit. // | isInteger (s [,eok]) True if all characters in string s are numbers. // | isSignedInteger (s [,eok]) True if all characters in string s are numbers; leading + or - allowed. // | isPositiveInteger (s [,eok]) True if string s is an integer > 0. // | isNonnegativeInteger (s [,eok]) True if string s is an integer >= 0. // | isNegativeInteger (s [,eok]) True if s is an integer < 0. // | isNonpositiveInteger (s [,eok]) True if s is an integer <= 0. // | isFloat (s [,eok]) True if string s is an unsigned floating point (real) number. (Integers also OK.) // | isSignedFloat (s [,eok]) True if string s is a floating point number; leading + or - allowed. (Integers also OK.) // | isAlphabetic (s [,eok]) True if string s is English letters // | isAlphanumeric (s [,eok]) True if string s is English letters and numbers only. // | // | isInternationalPhoneNumber (s [,eok]) True if string s is a valid international phone number. // | isEmail (s [,eok]) True if string s is a valid email address. // | isYear (s [,eok]) True if string s is a valid Year number. // | isIntegerInRange (s, a, b [,eok]) True if string s is an integer between a and b, inclusive. // | isMonth (s [,eok]) True if string s is a valid month between 1 and 12. // | isDay (s [,eok]) True if string s is a valid day between 1 and 31. // | daysInFebruary (year) Returns number of days in February of that year. // | isDate (year, month, day) True if string arguments form a valid date. // | // |------------------------------------------------------------------------------------------------------------- // | FUNCTIONS TO REFORMAT DATA: // |------------------------------------------------------------------------------------------------------------- // | stripCharsInBag (s, bag) Removes all characters in string bag from string s. // | stripCharsNotInBag (s, bag) Removes all characters NOT in string bag from string s. // | stripWhitespace (s) Removes all whitespace characters from s. // | stripInitialWhitespace (s) Removes initial (leading) whitespace characters from s. // | reformat (TARGETSTRING, STRING, Function for inserting formatting characters or // | INTEGER, STRING, INTEGER ... ) delimiters into TARGETSTRING. // | // |------------------------------------------------------------------------------------------------------------- // | FUNCTIONS TO PROMPT USER: // |------------------------------------------------------------------------------------------------------------- // | prompt (s) Display prompt string s in status bar. // | promptEntry (s) Display data entry prompt string s in status bar. // | warnEmpty (theField, s) Notify user that required field theField is empty. // | warnInvalid (theField, s) Notify user that contents of field theField are invalid. // | // |------------------------------------------------------------------------------------------------------------- // | FUNCTIONS TO INTERACTIVELY CHECK FIELD CONTENTS: // |------------------------------------------------------------------------------------------------------------- // | checkString (theField, s [,eok]) Check that theField.value is not empty or all whitespace. // | checkInternationalPhone (theField [,eok]) Check that theField.value is a valid International Phone. // | checkEmail (theField [,eok]) Check that theField.value is a valid Email. // | checkYear (theField [,eok]) Check that theField.value is a valid Year. // | checkMonth (theField [,eok]) Check that theField.value is a valid Month. // | checkDay (theField [,eok]) Check that theField.value is a valid Day. // | checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay) // | // |------------------------------------------------------------------------------------------------------------- // | GLOBAL VARIABLES DESIGNED FOR USE IN MIAMEXPRESS FORMS: // |------------------------------------------------------------------------------------------------------------- // | List of global miamexpress variables. // | // |------------------------------------------------------------------------------------------------------------- // | COMMON FUNCTIONS DESIGNED FOR USE IN MIAMEXPRESS FORMS: // |------------------------------------------------------------------------------------------------------------- // | returnElement (elementName) Return the form element for a given element name. // | change () Update a global variable when any of the fields in the form were changed. // | checkSelectField (selectField, s, limit [,eok]) Check if a select field has been choosen properly. Checks for selected index equal to limit (usually, 0 or -1 for null). // | clearField (theElement) Clearing the element's field of any data (a select field will have 0 index). // | isURL (s [,eok]) True if s is a URL defined as beginning with http:// or https://. // | checkURL (theField [,eok]) Check that theField.value is a valid URL. // | checkListAndField (selectField, theField, listItem, desc) Checks for compatibility of list item selection and textfield entry. See also checkListAndField2. // | checkPositiveInteger (theField [,eok]) Check that theField.value is a valid Positive Integer. // | checkCheckboxItems (theForm, checkfield) Check that a checkbox field is selected and returns error message(s) if necessary. (See also checkCheckboxItemsWithoutErrorMessage) // | checkChange() Checks to see if any form changes need to be submitted beforehand. // | checkFloat (theField [,eok]) Check that string theField.value is a valid Float number (real number & >0). // | checkCheckboxItemsWithoutErrorMessage (checkfield) Check that a checkbox field is selected and dont return an error message. (See also checkCheckboxItems) // | checkStringWithoutErrorMessage (theField [,eok]) Check that string theField.value is not empty or all whitespace. Does not return an error message but returns a boolean back. (See also checkString) // | checkSelectFieldTwoItems (selectField) Checks if a multiple select type of field is filled in with two items selected. See also checkSelectFieldOneItems. // | checkSelectFieldOneItems (selectField) Checks if a multiple select type of field is filled in with one or more items selected. See also checkSelectFieldTwoItems. // | checkTwoFields (firstField, secondField) Checks that the first textfield is filled in if the second textfield is filled in. // | checkListAndField2 (selectField, theField, listItem, desc) Checks for compatibility of list item selection and textfield entry. See also checkListAndField. // | setAnchor (form, baseAddress, anchor) Sets the anchor field for the form's action method. // | showMessage (s) Shows a message and returns a true boolean back. // | checkSignedFloat (theField [,eok]) Check that string theField.value is a valid signed float number (real number & can have leading + or - sign). // | checkSelectFieldOneOrTwoItems (selectField) Checks if a multiple select type of field is filled in with one or two items selected. See also checkSelectFieldTwoItems and checkSelectFieldOneItems. // | checkTwoFieldsSizes (firstField, secondField) Checks that the first textfield is less than the second textfield. // | disableButtons(FORM form) Responsible for disabling all the buttons on the form. // | checkStringWithoutFocus (theField, s [,eok]) Check that theField.value is not empty or all whitespace. No field focus or selection...for use with hidden fields and file upload fields. // | checkSimilarity (firstField, secondField) Checks that the first textfield is the same as the second textfield...Password verification... // | checkMinimumSize (theField, size) Check that theField.value is not less than the minimum size. // | // |============================================================================================================== // // Performance hint: when you deploy this file on your website, strip out the // comment lines from the source code as well as any of the functions which // you don't need. This will give you a smaller .js file and achieve faster // downloads. // // Some functions were taken from here: // 18 Feb 97 created Eric Krock // Original JavaScript 1.0-only version (works on Nav2.x and higher) // available at http://developer.netscape.com/ // 4 Nov 97 rewritten to demonstrate use of JavaScript 1.2 regular expressions. // (code is simpler and shorter but works on Nav4.x and higher only) // (c) 1997 Netscape Communications Corporation // ---------------------------------------- // REGULAR EXPRESSION DECLARATIONS // ---------------------------------------- // // Notes which apply to all the regexps below: // (1) We want to only match strings exactly. In other words, // we only want to return true if the string being tested // matches the regular expression with no leading or trailing // unmatched characters. So, we begin each regexp with // the special character ^ (which matches beginning of input) // and end each regexp with the special character $ (which // matches end of input). // (2) In the below comments we use these abbreviations: // BOI = Beginning Of Input // EOI = End Of Input // (3) For explanations of the regexp special characters such as // ^ $ \s + [] \d * ! ? \ . // see http://developer.netscape.com/library/documentation/communicator/jsguide/regexp.htm // BOI, followed by one or more whitespace characters, followed by EOI. var reWhitespace = /^\s+$/ // BOI, followed by one lower or uppercase English letter, followed by EOI. var reLetter = /^[a-zA-Z]$/ // BOI, followed by one or more lower or uppercase English letters, // followed by EOI. var reAlphabetic = /^[a-zA-Z]+$/ // BOI, followed by one or more lower or uppercase English letters // or digits, followed by EOI. var reAlphanumeric = /^[a-zA-Z0-9]+$/ // BOI, followed by one digit, followed by EOI. var reDigit = /^\d/ // BOI, followed by one lower or uppercase English letter // or digit, followed by EOI. var reLetterOrDigit = /^([a-zA-Z]|\d)$/ // BOI, followed by one or more digits, followed by EOI. var reInteger = /^\d+$/ // BOI, followed by an optional + or -, followed by one or more digits, // followed by EOI. var reSignedInteger = /^(\+|-)?\d+$/ // BOI, followed by one of these two patterns: // (a) one or more digits, followed by ., followed by zero or more digits // (b) zero or more digits, followed by ., followed by one or more digits // ... followed by EOI. var reFloat = /^((\d+(\.\d*)?)|((\d*\.)?\d+))$/ // BOI, followed by an optional + or -, followed by one of these two patterns: // (a) one or more digits, followed by ., followed by zero or more digits // (b) zero or more digits, followed by ., followed by one or more digits // ... followed by EOI. var reSignedFloat = /^(((\+|-)?\d+(\.\d*)?)|((\+|-)?(\d*\.)?\d+))$/ // BOI, followed by one or more characters, followed by @, // followed by one or more characters, followed by ., // followed by one or more characters, followed by EOI. var reEmail = /^.+\@.+\..+$/ // BOI, followed by either http:// or https:// // followed by one or more characters, followed by EOI. var reURL = /^(http:\/\/|https:\/\/).+$/ // ---------------------------------------- // GLOBAL VARIABLE DECLARATIONS // ---------------------------------------- var digits = "0123456789"; var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz" var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" // whitespace characters as defined by this sample code var whitespace = " \t\n\r"; // non-digit characters which are allowed in phone numbers var phoneNumberDelimiters = "()- "; // characters which are allowed in international phone numbers // (a leading + is OK) var validWorldPhoneChars = digits + phoneNumberDelimiters + "+"; // Global boolean variable to see if the ReturnWhattodoElement "MX_PGVAR_WHATTODO" was found // Used in Change() function found for MIAMEXPRESS functions var foundReturnWhattodoElement = "FALSE" // ---------------------------------------- // GLOBAL CONSTANT STRING DECLARATIONS // ---------------------------------------- // (grouped for ease of translation and localization) // m is an abbreviation for "missing" var mPrefix = "You did not enter a value into the " var mSuffix = " field. This is a required field." // s is an abbreviation for "string" var sWorldLastName = "Last/Family Name" var sWorldFirstName = "First/Given Name" var sTitle = "Title" var sCompanyName = "Company Name, Institution or Organisation Name" var sWorldAddress = "Address" var sCity = "City" var sWorldState = "State, Province, County or Prefecture" var sCountry = "Country" var sWorldPostalCode = "Postal Code or ZIP Code" var sPhone = "Phone Number" var sFax = "Fax Number" var sDateOfBirth = "Date of Birth" var sEmail = "Email" var sOtherInfo = "Other Information" // i is an abbreviation for "invalid" var iWorldPhone = "This field must be a valid international phone number." var iEmail = "This field must be a valid email address (like foo@bar.com)." var iDay = "This field must be a day number between 1 and 31." var iMonth = "This field must be a month number between 1 and 12." var iYear = "This field must be a 2 or 4 digit year number.." var iDatePrefix = "The Day, Month, and Year for " var iDateSuffix = " do not form a valid date." // p is an abbreviation for "prompt" var pEntryPrompt = "Please enter a " var pWorldPhone = "international phone number." var pEmail = "valid email address (like whoever@wherever.com)." var pDay = "day number between 1 and 31." var pMonth = "month number between 1 and 12." var pYear = "2 or 4 digit year number." // Global variable defaultEmptyOK defines default return value // for many functions when they are passed the empty string. // By default, they will return defaultEmptyOK. // // defaultEmptyOK is false, which means that by default, // these functions will do "strict" validation. Function // isInteger, for example, will only return true if it is // passed a string containing an integer; if it is passed // the empty string, it will return false. // // You can change this default behavior globally (for all // functions which use defaultEmptyOK) by changing the value // of defaultEmptyOK. // // Most of these functions have an optional argument emptyOK // which allows you to override the default behavior for // the duration of a function call. // // This functionality is useful because it is possible to // say "if the user puts anything in this field, it must // be an integer (or a phone number, or a string, etc.), // but it's OK to leave the field empty too." // This is the case for fields which are optional but which // must have a certain kind of content if filled in. var defaultEmptyOK = true // ---------------------------------------- // FUNCTIONS // ---------------------------------------- // Attempting to make this library run on Navigator 2.0, // so I'm supplying this array creation routine as per // JavaScript 1.0 documentation. If you're using // Navigator 3.0 or later, you don't need to do this; // you can use the Array constructor instead. function makeArray(n) { //*** BUG: If I put this line in, I get two error messages: //(1) Window.length can't be set by assignment //(2) daysInMonth has no property indexed by 4 //If I leave it out, the code works fine. // this.length = n; for (var i = 1; i <= n; i++) { this[i] = 0 } return this } var daysInMonth = makeArray(12); daysInMonth[1] = 31; daysInMonth[2] = 29; // must programmatically check this daysInMonth[3] = 31; daysInMonth[4] = 30; daysInMonth[5] = 31; daysInMonth[6] = 30; daysInMonth[7] = 31; daysInMonth[8] = 31; daysInMonth[9] = 30; daysInMonth[10] = 31; daysInMonth[11] = 30; daysInMonth[12] = 31; // Check whether string s is empty. function isEmpty(s) { return ((s == null) || (s.length == 0)) } // Returns true if string s is empty or // whitespace characters only. function isWhitespace (s) { // Is s empty? return (isEmpty(s) || reWhitespace.test(s)); } // Removes all characters which appear in regexp bag from string s. // NOTES: // 1) bag must be a regexp which matches single characters in isolation, // i.e. A or B or C or D or 1 or 2 ... // e.g. /\d/g or /[a-zA-Z]/g // 2) make sure to append the 'g' modifier (for global search & replace) // at the end of the regexp // e.g. /\d/g or /[a-zA-Z]/g function stripCharsInRE (s, bag) { return s.replace(bag, "") } // Removes all characters which appear in string bag from string s. function stripCharsInBag (s, bag) { var i; var returnString = ""; // Search through string's characters one by one. // If character is not in bag, append to returnString. for (i = 0; i < s.length; i++) { // Check that current character isn't whitespace. var c = s.charAt(i); if (bag.indexOf(c) == -1) returnString += c; } return returnString; } // Removes all characters which do NOT appear in string bag // from string s. function stripCharsNotInBag (s, bag) { var i; var returnString = ""; // Search through string's characters one by one. // If character is in bag, append to returnString. for (i = 0; i < s.length; i++) { // Check that current character isn't whitespace. var c = s.charAt(i); if (bag.indexOf(c) != -1) returnString += c; } return returnString; } // Removes all whitespace characters from s. // Global variable whitespace (see above) // defines which characters are considered whitespace. function stripWhitespace (s) { return stripCharsInBag (s, whitespace) } // WORKAROUND FUNCTION FOR NAVIGATOR 2.0.2 COMPATIBILITY. // // The below function *should* be unnecessary. In general, // avoid using it. Use the standard method indexOf instead. // // However, because of an apparent bug in indexOf on // Navigator 2.0.2, the below loop does not work as the // body of stripInitialWhitespace: // // while ((i < s.length) && (whitespace.indexOf(s.charAt(i)) != -1)) // i++; // // ... so we provide this workaround function charInString // instead. // // charInString (CHARACTER c, STRING s) // // Returns true if single character c (actually a string) // is contained within string s. function charInString (c, s) { for (i = 0; i < s.length; i++) { if (s.charAt(i) == c) return true; } return false } // Removes initial (leading) whitespace characters from s. // Global variable whitespace (see above) // defines which characters are considered whitespace. function stripInitialWhitespace (s) { var i = 0; while ((i < s.length) && charInString (s.charAt(i), whitespace)) i++; return s.substring (i, s.length); } // Returns true if character c is an English letter // (A .. Z, a..z). // // NOTE: Need i18n version to support European characters. // This could be tricky due to different character // sets and orderings for various languages and platforms. function isLetter (c) { return reLetter.test(c) } // Returns true if character c is a digit // (0 .. 9). function isDigit (c) { return reDigit.test(c) } // Returns true if character c is a letter or digit. function isLetterOrDigit (c) { return reLetterOrDigit.test(c) } // isInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if all characters in string s are numbers. // // Accepts non-signed integers only. Does not accept floating // point, exponential notation, etc. // // We don't use parseInt because that would accept a string // with trailing non-numeric characters. // // By default, returns defaultEmptyOK if s is empty. // There is an optional second argument called emptyOK. // emptyOK is used to override for a single function call // the default behavior which is specified globally by // defaultEmptyOK. // If emptyOK is false (or any value other than true), // the function will return false if s is empty. // If emptyOK is true, the function will return true if s is empty. // // EXAMPLE FUNCTION CALL: RESULT: // isInteger ("5") true // isInteger ("") defaultEmptyOK // isInteger ("-5") false // isInteger ("", true) true // isInteger ("", false) false // isInteger ("5", false) true function isInteger (s) { var i; if (isEmpty(s)) if (isInteger.arguments.length == 1) return defaultEmptyOK; else return (isInteger.arguments[1] == true); return reInteger.test(s) } // isSignedInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if all characters are numbers; // first character is allowed to be + or - as well. // // Does not accept floating point, exponential notation, etc. // // We don't use parseInt because that would accept a string // with trailing non-numeric characters. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // // EXAMPLE FUNCTION CALL: RESULT: // isSignedInteger ("5") true // isSignedInteger ("") defaultEmptyOK // isSignedInteger ("-5") true // isSignedInteger ("+5") true // isSignedInteger ("", false) false // isSignedInteger ("", true) true function isSignedInteger (s) { if (isEmpty(s)) if (isSignedInteger.arguments.length == 1) return defaultEmptyOK; else return (isSignedInteger.arguments[1] == true); else { return reSignedInteger.test(s) } } // isPositiveInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is an integer > 0. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isPositiveInteger (s) { var secondArg = defaultEmptyOK; if (isPositiveInteger.arguments.length > 1) secondArg = isPositiveInteger.arguments[1]; // The next line is a bit byzantine. What it means is: // a) s must be a signed integer, AND // b) one of the following must be true: // i) s is empty and we are supposed to return true for // empty strings // ii) this is a positive, not negative, number return (isSignedInteger(s, secondArg) && ( (isEmpty(s) && secondArg) || (parseInt (s) > 0) ) ); } // isNonnegativeInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is an integer >= 0. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isNonnegativeInteger (s) { var secondArg = defaultEmptyOK; if (isNonnegativeInteger.arguments.length > 1) secondArg = isNonnegativeInteger.arguments[1]; // The next line is a bit byzantine. What it means is: // a) s must be a signed integer, AND // b) one of the following must be true: // i) s is empty and we are supposed to return true for // empty strings // ii) this is a number >= 0 return (isSignedInteger(s, secondArg) && ( (isEmpty(s) && secondArg) || (parseInt (s) >= 0) ) ); } // isNegativeInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is an integer < 0. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isNegativeInteger (s) { var secondArg = defaultEmptyOK; if (isNegativeInteger.arguments.length > 1) secondArg = isNegativeInteger.arguments[1]; // The next line is a bit byzantine. What it means is: // a) s must be a signed integer, AND // b) one of the following must be true: // i) s is empty and we are supposed to return true for // empty strings // ii) this is a negative, not positive, number return (isSignedInteger(s, secondArg) && ( (isEmpty(s) && secondArg) || (parseInt (s) < 0) ) ); } // isNonpositiveInteger (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is an integer <= 0. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isNonpositiveInteger (s) { var secondArg = defaultEmptyOK; if (isNonpositiveInteger.arguments.length > 1) secondArg = isNonpositiveInteger.arguments[1]; // The next line is a bit byzantine. What it means is: // a) s must be a signed integer, AND // b) one of the following must be true: // i) s is empty and we are supposed to return true for // empty strings // ii) this is a number <= 0 return (isSignedInteger(s, secondArg) && ( (isEmpty(s) && secondArg) || (parseInt (s) <= 0) ) ); } // isFloat (STRING s [, BOOLEAN emptyOK]) // // True if string s is an unsigned floating point (real) number. // // Also returns true for unsigned integers. If you wish // to distinguish between integers and floating point numbers, // first call isInteger, then call isFloat. // // Does not accept exponential notation. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isFloat (s) { if (isEmpty(s)) if (isFloat.arguments.length == 1) return defaultEmptyOK; else return (isFloat.arguments[1] == true); return reFloat.test(s) } // isSignedFloat (STRING s [, BOOLEAN emptyOK]) // // True if string s is a signed or unsigned floating point // (real) number. First character is allowed to be + or -. // // Also returns true for unsigned integers. If you wish // to distinguish between integers and floating point numbers, // first call isSignedInteger, then call isSignedFloat. // // Does not accept exponential notation. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isSignedFloat (s) { if (isEmpty(s)) if (isSignedFloat.arguments.length == 1) return defaultEmptyOK; else return (isSignedFloat.arguments[1] == true); else { return reSignedFloat.test(s) } } // isAlphabetic (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is English letters // (A .. Z, a..z) only. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // // NOTE: Need i18n version to support European characters. // This could be tricky due to different character // sets and orderings for various languages and platforms. function isAlphabetic (s) { var i; if (isEmpty(s)) if (isAlphabetic.arguments.length == 1) return defaultEmptyOK; else return (isAlphabetic.arguments[1] == true); else { return reAlphabetic.test(s) } } // isAlphanumeric (STRING s [, BOOLEAN emptyOK]) // // Returns true if string s is English letters // (A .. Z, a..z) and numbers only. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // // NOTE: Need i18n version to support European characters. // This could be tricky due to different character // sets and orderings for various languages and platforms. function isAlphanumeric (s) { var i; if (isEmpty(s)) if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK; else return (isAlphanumeric.arguments[1] == true); else { return reAlphanumeric.test(s) } } // reformat (TARGETSTRING, STRING, INTEGER, STRING, INTEGER ... ) // // Handy function for arbitrarily inserting formatting characters // or delimiters of various kinds within TARGETSTRING. // // reformat takes one named argument, a string s, and any number // of other arguments. The other arguments must be integers or // strings. These other arguments specify how string s is to be // reformatted and how and where other strings are to be inserted // into it. // // reformat processes the other arguments in order one by one. // * If the argument is an integer, reformat appends that number // of sequential characters from s to the resultString. // * If the argument is a string, reformat appends the string // to the resultString. // // NOTE: The first argument after TARGETSTRING must be a string. // (It can be empty.) The second argument must be an integer. // Thereafter, integers and strings must alternate. This is to // provide backward compatibility to Navigator 2.0.2 JavaScript // by avoiding use of the typeof operator. // // It is the caller's responsibility to make sure that we do not // try to copy more characters from s than s.length. // // EXAMPLES: // // * To reformat a 10-digit U.S. phone number from "1234567890" // to "(123) 456-7890" make this function call: // reformat("1234567890", "(", 3, ") ", 3, "-", 4) // // * To reformat a 9-digit U.S. Social Security number from // "123456789" to "123-45-6789" make this function call: // reformat("123456789", "", 3, "-", 2, "-", 4) // // HINT: // // If you have a string which is already delimited in one way // (example: a phone number delimited with spaces as "123 456 7890") // and you want to delimit it in another way using function reformat, // call function stripCharsNotInBag to remove the unwanted // characters, THEN call function reformat to delimit as desired. // // EXAMPLE: // // reformat (stripCharsNotInBag ("123 456 7890", digits), // "(", 3, ") ", 3, "-", 4) function reformat (s) { var arg; var sPos = 0; var resultString = ""; for (var i = 1; i < reformat.arguments.length; i++) { arg = reformat.arguments[i]; if (i % 2 == 1) resultString += arg; else { resultString += s.substring(sPos, sPos + arg); sPos += arg; } } return resultString; } // isInternationalPhoneNumber (STRING s [, BOOLEAN emptyOK]) // // isInternationalPhoneNumber returns true if string s is a valid // international phone number. Must be digits only; any length OK. // May be prefixed by + character. // // NOTE: A phone number of all zeros would not be accepted. // I don't think that is a valid phone number anyway. // // NOTE: Strip out any delimiters (spaces, hyphens, parentheses, etc.) // from string s before calling this function. You may leave in // leading + character if you wish. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isInternationalPhoneNumber (s) { if (isEmpty(s)) if (isInternationalPhoneNumber.arguments.length == 1) return defaultEmptyOK; else return (isInternationalPhoneNumber.arguments[1] == true); return (isPositiveInteger(s)) } // isEmail (STRING s [, BOOLEAN emptyOK]) // // Email address must be of form a@b.c -- in other words: // * there must be at least one character before the @ // * there must be at least one character before and after the . // * the characters @ and . are both required // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isEmail (s) { if (isEmpty(s)) if (isEmail.arguments.length == 1) return defaultEmptyOK; else return (isEmail.arguments[1] == true); else { return reEmail.test(s) } } // isYear (STRING s [, BOOLEAN emptyOK]) // // isYear returns true if string s is a valid // Year number. Must be 2 or 4 digits only. // // For Year 2000 compliance, you are advised // to use 4-digit year numbers everywhere. // // And yes, this function is not Year 10000 compliant, but // because I am giving you 8003 years of advance notice, // I don't feel very guilty about this ... // // For B.C. compliance, write your own function. ;-> // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isYear (s) { if (isEmpty(s)) if (isYear.arguments.length == 1) return defaultEmptyOK; else return (isYear.arguments[1] == true); if (!isNonnegativeInteger(s)) return false; return ((s.length == 2) || (s.length == 4)); } // isIntegerInRange (STRING s, INTEGER a, INTEGER b [, BOOLEAN emptyOK]) // // isIntegerInRange returns true if string s is an integer // within the range of integer arguments a and b, inclusive. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isIntegerInRange (s, a, b) { if (isEmpty(s)) if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK; else return (isIntegerInRange.arguments[1] == true); // Catch non-integer strings to avoid creating a NaN below, // which isn't available on JavaScript 1.0 for Windows. if (!isInteger(s, false)) return false; // Now, explicitly change the type to integer via parseInt // so that the comparison code below will work both on // JavaScript 1.2 (which typechecks in equality comparisons) // and JavaScript 1.1 and before (which doesn't). var num = parseInt (s); return ((num >= a) && (num <= b)); } // isMonth (STRING s [, BOOLEAN emptyOK]) // // isMonth returns true if string s is a valid // month number between 1 and 12. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isMonth (s) { if (isEmpty(s)) if (isMonth.arguments.length == 1) return defaultEmptyOK; else return (isMonth.arguments[1] == true); return isIntegerInRange (s, 1, 12); } // isDay (STRING s [, BOOLEAN emptyOK]) // // isDay returns true if string s is a valid // day number between 1 and 31. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function isDay (s) { if (isEmpty(s)) if (isDay.arguments.length == 1) return defaultEmptyOK; else return (isDay.arguments[1] == true); return isIntegerInRange (s, 1, 31); } // daysInFebruary (INTEGER year) // // Given integer argument year, // returns number of days in February of that year. function daysInFebruary (year) { // February has 29 days in any year evenly divisible by four, // EXCEPT for centurial years which are not also divisible by 400. return ( ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 ); } // isDate (STRING year, STRING month, STRING day) // // isDate returns true if string arguments year, month, and day // form a valid date. // function isDate (year, month, day) { // catch invalid years (not 2- or 4-digit) and invalid months and days. if (! (isYear(year, false) && isMonth(month, false) && isDay(day, false))) return false; // Explicitly change type to integer to make code work in both // JavaScript 1.1 and JavaScript 1.2. var intYear = parseInt(year); var intMonth = parseInt(month); var intDay = parseInt(day); // catch invalid days, except for February if (intDay > daysInMonth[intMonth]) return false; if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) return false; return true; } // -------------------------------------------------------------- // FUNCTIONS TO NOTIFY USER OF INPUT REQUIREMENTS OR MISTAKES // -------------------------------------------------------------- // Display prompt string s in status bar. function prompt (s) { window.status = s } // Display data entry prompt string s in status bar. function promptEntry (s) { window.status = pEntryPrompt + s } // Notify user that required field theField is empty. // String s describes expected contents of theField.value. // Put focus in theField and return false. function warnEmpty (theField, s) { theField.focus() alert(mPrefix + s + mSuffix) return false } // Notify user that contents of field theField are invalid. // String s describes expected contents of theField.value. // Put select theField, pu focus in it, and return false. function warnInvalid (theField, s) { theField.focus() if (theField.type == "text") theField.select() alert(s) return false } // -------------------------------------------------------------- // FUNCTIONS TO INTERACTIVELY CHECK VARIOUS FIELDS // -------------------------------------------------------------- // checkString (TEXTFIELD theField, STRING s, [, BOOLEAN emptyOK==false]) // // Check that string theField.value is not all whitespace. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkString (theField, s, emptyOK) { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkString.arguments.length == 2) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (isWhitespace(theField.value)) return warnEmpty (theField, s); else return true; } // checkInternationalPhone (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Check that string theField.value is a valid International Phone. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkInternationalPhone (theField, emptyOK) { if (checkInternationalPhone.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else { if (!isInternationalPhoneNumber(theField.value, false)) return warnInvalid (theField, iWorldPhone); else return true; } } // checkEmail (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Check that string theField.value is a valid Email. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkEmail (theField, emptyOK) { if (checkEmail.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else if (!isEmail(theField.value, false)) return warnInvalid (theField, iEmail); else return true; } // Check that string theField.value is a valid Year. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkYear (theField, emptyOK) { if (checkYear.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (!isYear(theField.value, false)) return warnInvalid (theField, iYear); else return true; } // Check that string theField.value is a valid Month. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkMonth (theField, emptyOK) { if (checkMonth.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (!isMonth(theField.value, false)) return warnInvalid (theField, iMonth); else return true; } // Check that string theField.value is a valid Day. // // For explanation of optional argument emptyOK, // see comments of function isInteger. function checkDay (theField, emptyOK) { if (checkDay.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (!isDay(theField.value, false)) return warnInvalid (theField, iDay); else return true; } // checkDate (yearField, monthField, dayField, STRING labelString [, OKtoOmitDay==false]) // // Check that yearField.value, monthField.value, and dayField.value // form a valid date. // // If they don't, labelString (the name of the date, like "Birth Date") // is displayed to tell the user which date field is invalid. // // If it is OK for the day field to be empty, set optional argument // OKtoOmitDay to true. It defaults to false. function checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay) { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkDate.arguments.length == 4) OKtoOmitDay = false; if (!isYear(yearField.value)) return warnInvalid (yearField, iYear); if (!isMonth(monthField.value)) return warnInvalid (monthField, iMonth); if ( (OKtoOmitDay == true) && isEmpty(dayField.value) ) return true; else if (!isDay(dayField.value)) return warnInvalid (dayField, iDay); if (isDate (yearField.value, monthField.value, dayField.value)) return true; alert (iDatePrefix + labelString + iDateSuffix) return false } // ------------------------------------------------------------------------------- // GLOBAL VARIABLES DESIGNED FOR USE IN MIAMEXPRESS FORMS // ------------------------------------------------------------------------------- // Submit button success text var MX_SUBMIT_SUCCESS = "Data submitted successfully."; // Array Design Submissions Selection Page: var MX_PGVAR_ARRAYDESIGNSELSUB_VIEWEDIT_BUTTON = "View/Edit"; var MX_PGVAR_ARRAYDESIGNSELSUB_CREATE_BUTTON = "Create"; // Array Design Submissions Page: var MX_PGVAR_ARRAYDESIGNSUB_APPLY = "Submit"; // Experiment Submissions Page: var MX_PGVAR_EXPRMNTSELSUB_VIEWEDIT_BUTTON = "View/Edit"; var MX_PGVAR_EXPRMNTSELSUB_CREATE_BUTTON = "Create"; // Experimental Design Page: var MX_PGVAR_EXPRDESIN_APPLY = "Submit"; var MX_PGVAR_EXPRDESIN_CREATESAMPLES = "Create"; var MX_PGVAR_EXPRDESIN_VIEWEDIT_SAMPLE = "View/Edit"; var MX_PGVAR_EXPRDESIN_REMOVE_SAMPLE = "Remove"; // Publications Page: var MX_PGVAR_PUBLICATION_APPLY = "Submit"; var MX_PGVAR_PUBLICATION_CREATE_AUTHOR = "Create"; var MX_PGVAR_PUBLICATION_VIEWEDIT_AUTHOR = "View/Edit"; var MX_PGVAR_PUBLICATION_REMOVE_AUTHOR = "Remove"; // Extract Page: var MX_PGVAR_EXTRACT_APPLY = "Submit"; var MX_PGVAR_EXTRACT_CREATELABEL = "Create"; var MX_PGVAR_EXTRACT_VIEWEDIT_LABEL = "View/Edit"; var MX_PGVAR_EXTRACT_REMOVE_LABEL = "Remove"; // Extract Protocol Page: var MX_PGVAR_EXTRACTPRTCL_APPLY = "Submit"; // Label's Page: var MX_PGVAR_LABEL_APPLY = "Submit"; var MX_PGVAR_LABEL_GOTOHYBRIDS = "To hybridizations"; var MX_PGVAR_LABEL_VIEWEDIT_HYBRID = "View/Edit"; var MX_PGVAR_LABEL_REMOVE_HYBRID = "Remove"; // Label Protocol Page: var MX_PGVAR_LABELPRTCL_APPLY = "Submit"; // Label Hybridisation Page: var MX_PGVAR_LABHYB_APPLY = "Submit"; var MX_PGVAR_LABHYB_CREATEHYBRIDS = "Create"; var MX_PGVAR_LABHYB_VIEWEDIT_HYBRIDS = "View/Edit"; var MX_PGVAR_LABHYB_REVIEW = "Review"; var MX_PGVAR_LABHYB_REMOVE_HYBRIDS = "Remove"; var MX_PGVAR_LABHYB_COMPLETE_SUBMISSION = "Complete submission"; // Main Protocol Page: var MX_PGVAR_ALLPRTCLS_EXTRACTVIEWDETAIL = "Edit extract protocol detail"; var MX_PGVAR_ALLPRTCLS_EXTRACTREMOVE = "Remove extract protocol"; var MX_PGVAR_ALLPRTCLS_LABELVIEWDETAIL = "Edit label protocol detail"; var MX_PGVAR_ALLPRTCLS_LABELREMOVE = "Remove label protocol"; var MX_PGVAR_ALLPRTCLS_HYBRIDVIEWDETAIL = "Edit hyb. protocol detail"; var MX_PGVAR_ALLPRTCLS_HYBRIDREMOVE = "Remove hyb. protocol"; var MX_PGVAR_ALLPRTCLS_SCANVIEWDETAIL = "Edit scan protocol detail"; var MX_PGVAR_ALLPRTCLS_SCANREMOVE = "Remove scan protocol"; // Sample Page: var MX_PGVAR_SAMPLE_APPLY = "Submit"; var MX_PGVAR_SAMPLE_CREATEXTRACTS = "Create"; var MX_PGVAR_SAMPLE_VIEWEDIT_EXTRACT = "View/Edit"; var MX_PGVAR_SAMPLE_REMOVE_EXTRACT = "Remove"; // Scan Protocol Page: var MX_PGVAR_SCANPRTCL_APPLY = "Submit"; // Hybridization Protocol Page: var MX_PGVAR_HYBRIDPRTCL_APPLY = "Submit"; // Final Experiment Submission Page: var MX_PGVAR_EXPRFNL_APPLY = "Submit"; // ------------------------------------------------------------------------------- // COMMON MIAMEXPRESS FUNCTIONS // ------------------------------------------------------------------------------- // ------------------------------------------------------------------------------- // returnElement(FORM_ELEMENT elementName) // // Argument consideration: // (IN) A form element's name // (OUT) Reference to the form element // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for returning the form element for a given element // name. // ------------------------------------------------------------------------------- function returnElement(elementName) { var form = document.forms[0]; for (var i=0; i < form.elements.length; i++) { if (form.elements[i].name == elementName) { return form.elements[i]; } } } // ------------------------------------------------------------------------------- // change() // // Argument consideration: // (IN) // (OUT) // (GLOBAL VARIABLES) foundReturnWhattodoElement // (OTHER FUNCTIONS USED) returnElement(elementName) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is used to determine if any of the fields in the form were changed // or updated. // It makes use of the global variable "foundReturnWhattodoElement" to first test and // see if any of the fields were changed previously. // ------------------------------------------------------------------------------- function change() { if (foundReturnWhattodoElement == "FALSE") { var theElement = returnElement("MX_PGVAR_WHATTODO"); theElement.value = "UPDATE"; foundReturnWhattodoElement = "TRUE" } } // ------------------------------------------------------------------------------- // checkSelectField (SELECTFIELD selectField, STRING s, STRING limit [, BOOLEAN emptyOK==false] ) // // Argument consideration: // (IN) a SELECT type of field from the form, field name string to be displayed on error prompt, optional boolean empty argument // (OUT) returns a boolean back with an optional error prompt if necessary through another function // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) warnInvalid(theField, s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking if a select type of field is filled in. // A select field is not filled in if its selected index is equal to limit (for example, // 0 or -1 for null). // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkSelectField (selectField, s, limit, emptyOK) { var ret; // variable to store the return result if (limit == "null") { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkSelectField.arguments.length == 2) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (selectField.options.selectedIndex == -1)) ret = true; if ((emptyOK == false) && (selectField.options.selectedIndex == -1)) ret = warnInvalid (selectField, s); else ret = true; } else { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkSelectField.arguments.length == 2) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (selectField.options.selectedIndex == limit)) ret = true; if ((emptyOK == false) && (selectField.options.selectedIndex == limit)) ret = warnInvalid (selectField, s); else ret = true; } return ret; } // ------------------------------------------------------------------------------- // clearField(FORM_ELEMENT theElement) // // Argument consideration: // (IN) a field from the form // (OUT) // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for clearing the element's field of any entries. // In the case of a select type of field, then its index will be set to 0. // ------------------------------------------------------------------------------- function clearField(theElement) { if (theElement.type == "select-one" || theElement.type == "select-multiple") theElement.options[0].selected = true; else theElement.value=""; } // ------------------------------------------------------------------------------- // isURL (STRING s [, BOOLEAN emptyOK]) // // Argument consideration: // (IN) a string containing the entry to be checked, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK, reURL // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // URL (Uniform Resource Locator) must be of form http or https // followed by one or more characters. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function isURL (s) { if (isEmpty(s)) { if (isURL.arguments.length == 1) return defaultEmptyOK; else return (isURL.arguments[1] == true); } else return reURL.test(s) } // ------------------------------------------------------------------------------- // checkURL (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) the entry to be checked, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK, reURL // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s), isURL(s [,eok]) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is a valid URL. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkURL (theField, emptyOK) { if (checkURL.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else if (!isURL(theField.value, false)) return warnInvalid (theField, "This field must be a valid URL address, starting with either http:// or https://. Please reenter it now."); else return true; } // ------------------------------------------------------------------------------- // checkListAndField (SELECTFIELD selectField, TEXTFIELD theField, STRING listItem, STRING desc) // // Argument consideration: // (IN) the select field containing the list items, the text field requiring the description of the list item, a string containing the list item's text as specified in the list, a string describing the two fields // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Checks for two things in a "Other" example (2 error messages should be displayed): // (1) If the "Other" text field is filled in, then "Other" should be chosen in the select field. // (2) If "Other" is chosen in the select field, then the "Other" text field should be filled in with some text. // A FOR loop statement is needed to cycle through all the options from a "multiple" select list. // ------------------------------------------------------------------------------- function checkListAndField (selectField, theField, listItem, desc) { // Variable used to determine the error type produced: // If error_type = 0, then no error message. // If error_type = 1, then display first error message. // If error_type = 2, then display second error message. var error_type = 0 for (var i=0; i < selectField.length; i++) { if ((!isEmpty(theField.value)) && (selectField.options[i].text!=listItem) && (selectField.options[i].selected)) error_type = 1; if ((selectField.options[i].text==listItem) && (isEmpty(theField.value)) && (selectField.options[i].selected)) error_type = 2; if ((!isEmpty(theField.value)) && (selectField.options[i].text==listItem) && (selectField.options[i].selected)) { error_type = 0; break; } } if (error_type == 1) return warnInvalid (theField, "You have entered some text into the '" + listItem + "' " + desc + " textfield but you have not selected the option '" + listItem + "' on the " + desc + " list field.\n Please either select the '" + listItem + "' option in the list field or remove the text from the '" + listItem + "' " + desc + " textfield."); else if (error_type == 2) return warnInvalid (theField, "You have selected the '" + listItem + "' option from the " + desc + " list field but you have not entered any text into the '" + listItem + "' " + desc + " textfield.\n Please either enter some text into the '" + listItem + "' textfield or select another option from the " + desc + " list field."); else return true; } // ------------------------------------------------------------------------------- // checkPositiveInteger (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) the entry to be checked, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s), isPositiveInteger(s [,eok]) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is a valid Positive Integer. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkPositiveInteger (theField, emptyOK) { if (checkPositiveInteger.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else { if (!isPositiveInteger(theField.value, false)) return warnInvalid (theField, "Only positive integers (>0) are allowed in this field."); else return true; } } // ------------------------------------------------------------------------------- // checkCheckboxItems (FORM theForm, CHECKBOXFIELD checkfield) // // Argument consideration: // (IN) form, checkbox field(s) // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // 1.1 Niran Abeygunawardena 10/04/2002 Modified to accomodate Netscape 4 bug with checkfield.length function and now also checks if there are any checkboxes on the form beforehand. // ------------------------------------------------------------------------------- // Description: // Check that a checkbox field is selected. Returns an error message(s) if necessary. // ------------------------------------------------------------------------------- function checkCheckboxItems (theForm, checkfield) { // Boolean variable to check if it is safe to return // If safe=0, return safely // If safe=1, display error message 1 // If safe=2, display error message 2 var safe = 2; var noOfCheckboxes = 0; // Variable to store the number of checkbox items found if (checkfield == null) { safe=1; } else { for (var i=0; i 0) { for (var i=0; i < noOfCheckboxes; i++) { if (checkfield[i].checked) safe=0; } } if (safe==1) { alert("There are no checkbox items to select. Please create some first and try again."); return false; } else if (safe==2) { alert("Please select/check at least one entry before clicking on this button."); return false; } else return true; } // ------------------------------------------------------------------------------- // checkChange () // // Argument consideration: // (IN) // (OUT) returns a boolean back. // (GLOBAL VARIABLES) foundReturnWhattodoElement // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Checks to see if any form changes need to be submitted beforehand. // ------------------------------------------------------------------------------- function checkChange() { var ret = true; // variable to store return result if (foundReturnWhattodoElement=="TRUE") ret = confirm("The form's values have changed but you have not submitted the changes yet.\n If you want to save the changes first, please click 'CANCEL' and submit the form first.\n Otherwise, if you do not wish to save any of the current changes, please click 'OK'.") return ret } // ------------------------------------------------------------------------------- // checkFloat (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) the entry to be checked, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s), isFloat (s [,eok]) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is a valid Float number (real number). // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkFloat (theField, emptyOK) { if (checkFloat.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else { if (!isFloat(theField.value, false)) return warnInvalid (theField, "Only real numbers (>0) are allowed in this field."); else return true; } } // ------------------------------------------------------------------------------- // checkCheckboxItemsWithoutErrorMessage (CHECKBOXFIELD checkfield) // // Argument consideration: // (IN) checkbox field(s) // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that a checkbox field is selected. Does not return an error message. // ------------------------------------------------------------------------------- function checkCheckboxItemsWithoutErrorMessage (checkfield) { if (checkfield.checked) return true; else return false; } // ------------------------------------------------------------------------------- // checkStringWithoutErrorMessage (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) textfield, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) isEmpty(s), isWhitespace (s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is not empty or all whitespace. Does not return an error message // but returns a boolean back. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkStringWithoutErrorMessage (theField, emptyOK) { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkStringWithoutErrorMessage.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (isWhitespace(theField.value)) {theField.focus(), theField.select(); return false;} else return true; } // ------------------------------------------------------------------------------- // checkSelectFieldTwoItems (SELECTFIELD selectField) // // Argument consideration: // (IN) a multiple SELECT type of field from the form // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking if a multiple select type of field is // filled in with two items selected. // ------------------------------------------------------------------------------- function checkSelectFieldTwoItems (selectField) { var noOfSelectItems =0; // variable to store number of selected items for (var i=0; i < selectField.length; i++) { if (selectField.options[i].selected) noOfSelectItems += 1; } if (noOfSelectItems=="2") return true; else {selectField.focus(); return false;} } // ------------------------------------------------------------------------------- // checkSelectFieldOneItems (SELECTFIELD selectField) // // Argument consideration: // (IN) a multiple SELECT type of field from the form // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 31/05/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking if a multiple select type of field is // filled in with one or more items selected. // ------------------------------------------------------------------------------- function checkSelectFieldOneItems (selectField) { var noOfSelectItems =0; // variable to store number of selected items for (var i=0; i < selectField.length; i++) { if (selectField.options[i].selected) noOfSelectItems += 1; } if (noOfSelectItems>0) return true; else {selectField.focus(); return false;} } // ------------------------------------------------------------------------------- // checkTwoFields (TEXTFIELD firstField, TEXTFIELD secondField) // // Argument consideration: // (IN) first textfield that should be checked against, second textfield that should be checked with // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) isWhitespace (s), warnInvalid(theField, s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 03/05/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking that the first textfield is filled in // if the second textfield is filled in. // ------------------------------------------------------------------------------- function checkTwoFields (firstField, secondField) { // Boolean variable to check if it is safe to return // If safe=0, return safely // If safe=1, display error message var safe =0; if (!isWhitespace(secondField.value)) { if (isWhitespace(firstField.value)) safe=1; } if (safe==1) { return warnInvalid (secondField, "You have entered some text into the second field (example, max. field) but you have not entered anything into the first field (example, min. field). Please either enter some text into the first field or delete the text from the second field."); return false; } else return true; } // ------------------------------------------------------------------------------- // checkListAndField2 (SELECTFIELD selectField, TEXTFIELD theField, STRING listItem, STRING desc) // // Argument consideration: // (IN) the select field containing the list items, the text field requiring the description of the list item, a string containing the list item's text as specified in the list, a string describing the two fields // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 08/05/2002 Create // ------------------------------------------------------------------------------- // Description: // Checks for two things in a "Other" example (2 error messages should be displayed): // (1) If the "Other" text field is filled in, then "Other" should NOT be chosen in the select field. // (2) If "Other" is chosen in the select field, then the "Other" text field should NOT be filled in with some text. // A FOR loop statement is needed to cycle through all the options from a "multiple" select list. // ------------------------------------------------------------------------------- function checkListAndField2 (selectField, theField, listItem, desc) { // Variable used to determine the error type produced: // If error_type = 0, then no error message. // If error_type = 1, then display first error message. // If error_type = 2, then display second error message. var error_type = 0 for (var i=0; i < selectField.length; i++) { if ((!isEmpty(theField.value)) && (selectField.options[i].text==listItem) && (selectField.options[i].selected)) error_type = 1; if ((selectField.options[i].text!=listItem) && (isEmpty(theField.value)) && (selectField.options[i].selected)) error_type = 2; //if ((isEmpty(theField.value)) && (selectField.options[i].text!=listItem) && (selectField.options[i].selected)) // error_type = 0; } if (error_type == 1) return warnInvalid (theField, "You have entered some text into the " + desc + " textfield but you have selected the option '" + listItem + "' on the " + desc + " list field.\n Please either select another option in the list field or remove the text from the textfield."); else if (error_type == 2) return warnInvalid (theField, "You have selected an option from the " + desc + " list field that requires you to enter some text into the " + desc + " textfield.\n Please either enter some text into the textfield or select the '" + listItem + "' option from the " + desc + " list field."); else return true; } // ------------------------------------------------------------------------------- // setAnchor (form, baseAddress, anchor) // // Argument consideration: // (IN) form, the base url address of the cgi script, anchor field (without #). // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 10/06/2002 Create // ------------------------------------------------------------------------------- // Description: // Sets the anchor field for the form's action method. // ------------------------------------------------------------------------------- function setAnchor(form, baseAddress, anchor) { form.action=baseAddress+"#"+anchor; return true; } // ------------------------------------------------------------------------------- // showMessage(s) // // Argument consideration: // (IN) a string with the message. // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 02/08/2002 Create // ------------------------------------------------------------------------------- // Description: // This function shows a message and returns a true boolean back. // ------------------------------------------------------------------------------- function showMessage(s) { alert(s) return true; } // ------------------------------------------------------------------------------- // checkSignedFloat (TEXTFIELD theField [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) the entry to be checked, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) warnInvalid(theField, s), isEmpty(s), isSignedFloat(s [,eok]) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 22/02/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is a valid signed float number (+ or - allowed). // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkSignedFloat (theField, emptyOK) { if (checkSignedFloat.arguments.length == 1) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; else { if (!isSignedFloat(theField.value, false)) return warnInvalid (theField, "Only real numbers are allowed. (use of leading + or - allowed too)"); else return true; } } // ------------------------------------------------------------------------------- // checkSelectFieldOneOrTwoItems (SELECTFIELD selectField) // // Argument consideration: // (IN) a multiple SELECT type of field from the form // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 31/05/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking if a multiple select type of field is // filled in with one or two items selected. // ------------------------------------------------------------------------------- function checkSelectFieldOneOrTwoItems (selectField) { var noOfSelectItems =0; // variable to store number of selected items for (var i=0; i < selectField.length; i++) { if (selectField.options[i].selected) noOfSelectItems += 1; } if (noOfSelectItems=="1" || noOfSelectItems=="2") return true; else {selectField.focus(); return false;} } // ------------------------------------------------------------------------------- // checkTwoFieldsSizes (TEXTFIELD firstField, TEXTFIELD secondField) // // Argument consideration: // (IN) first textfield that should be checked against, second textfield that should be checked with // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) isWhitespace (s), warnInvalid(theField, s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 17/08/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking that the first textfield is less than // the second textfield. // ------------------------------------------------------------------------------- function checkTwoFieldsSizes (firstField, secondField) { if (!isWhitespace(secondField.value)) { if (isNaN(parseFloat(firstField.value))) { return warnInvalid (firstField, "Only real numbers (>0) are allowed in this field."); return false; } if (isNaN(parseFloat(secondField.value))) { return warnInvalid (secondField, "Only real numbers (>0) are allowed in this field."); return false; } if (firstField.value >= secondField.value) { return warnInvalid (firstField, "Make sure that the first field is less than the second field."); return false; } else return true; } return true; } // ------------------------------------------------------------------------------- // disableButtons(FORM form) // // Argument consideration: // (IN) A form // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 30/10/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for disabling all the buttons on the form. // ------------------------------------------------------------------------------- function disableButtons(form) { if (navigator.appName != "Netscape") { for (var i=0; i < form.elements.length; i++) { if (form.elements[i].type.toLowerCase()=="submit"||form.elements[i].type.toLowerCase()=="reset") { form.elements[i].disabled=true; } } } return true; } // ------------------------------------------------------------------------------- // checkStringWithoutFocus (TEXTFIELD theField, STRING s [, BOOLEAN emptyOK==false]) // // Argument consideration: // (IN) text field, a string with the message, optional boolean empty argument // (OUT) returns a boolean back. // (GLOBAL VARIABLES) defaultEmptyOK // (OTHER FUNCTIONS USED) isEmpty(s), isWhitespace (s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 05/11/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is not empty or all whitespace. No field focus // or selection. // // For explanation of optional argument emptyOK, // see comments of function isInteger. // ------------------------------------------------------------------------------- function checkStringWithoutFocus (theField, s, emptyOK) { // Next line is needed on NN3 to avoid "undefined is not a number" error // in equality comparison below. if (checkStringWithoutFocus.arguments.length == 2) emptyOK = defaultEmptyOK; if ((emptyOK == true) && (isEmpty(theField.value))) return true; if (isWhitespace(theField.value)) {alert(s); return false;} else return true; } // ------------------------------------------------------------------------------- // checkSimilarity (TEXTFIELD firstField, TEXTFIELD secondField) // // Argument consideration: // (IN) first textfield that should be checked against, second textfield that should be checked with // (OUT) returns a boolean back // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) warnInvalid(theField, s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 18/11/2002 Create // ------------------------------------------------------------------------------- // Description: // This function is responsible for checking that the first textfield is the same as // the second textfield...Password verification... // ------------------------------------------------------------------------------- function checkSimilarity (firstField, secondField) { if (firstField.value != secondField.value) { firstField.value = ""; secondField.value = ""; return warnInvalid (firstField, "Make sure that the first field is the same as the second field."); return false; } return true; } // ------------------------------------------------------------------------------- // checkMinimumSize (TEXTFIELD theField, STRING size) // // Argument consideration: // (IN) text field, the minimum size for the field // (OUT) returns a boolean back. // (GLOBAL VARIABLES) // (OTHER FUNCTIONS USED) warnInvalid(theField, s) // // Ver Author Date Comments // ------------------------------------------------------------------------------- // 1.0 Niran Abeygunawardena/Mohammadreza Shojatalab 18/11/2002 Create // ------------------------------------------------------------------------------- // Description: // Check that string theField.value is not less than the minimum size. // // ------------------------------------------------------------------------------- function checkMinimumSize (theField, size) { var contents = theField.value; if (contents.length < parseInt(size)) return warnInvalid (theField, "The minimum number of characters for this field is "+ size +"."); else return true; }