//-----------------------------------------------------------------------------
// sortTable(id, col, rev)
//
//  id  - ID of the TABLE, TBODY, THEAD or TFOOT element to be sorted.
//  col - Index of the column to sort, 0 = first column, 1 = second column,
//        etc.
//  rev - If true, the column is sorted in reverse (descending) order
//        initially.
//
// Note: the team name column (index 1) is used as a secondary sort column and
// always sorted in ascending order.
//-----------------------------------------------------------------------------

			function sortTable(id, col, rev) {
			
			// Get the table or table section to sort.
			var tblEl = document.getElementById(id);
			// The first time this function is called for a given table, set up an
			// array of reverse sort flags.
			if (tblEl.reverseSort == null) {
				tblEl.reverseSort = new Array();
				// Also, assume the team name column is initially sorted.
				tblEl.lastColumn = 1;
			}

			// If this column has not been sorted before, set the initial sort direction.
			if (tblEl.reverseSort[col] == null)
				tblEl.reverseSort[col] = rev;
	
			// If this column was the last one sorted, reverse its sort direction.
			if (col == tblEl.lastColumn)
				tblEl.reverseSort[col] = !tblEl.reverseSort[col];
	
			// Remember this column as the last one sorted.
			tblEl.lastColumn = col;
	
			// Set the table display style to "none" - necessary for Netscape 6 
			// browsers.
			var oldDsply = tblEl.style.display;
			tblEl.style.display = "none";
	
			// Sort the rows based on the content of the specified column using a
			// selection sort.
	
			var tmpEl;
			var i, j;
			var minVal, minIdx;
			var testVal;
			var cmp;
	
			for (i = 0; i < tblEl.rows.length - 1; i++) {
	
				// Assume the current row has the minimum value.
				minIdx = i;
				minVal = getTextValue(tblEl.rows[i].cells[col]);
	
				// Search the rows that follow the current one for a smaller value.
				for (j = i + 1; j < tblEl.rows.length; j++) {
					testVal = getTextValue(tblEl.rows[j].cells[col]);
					cmp = compareValues(minVal, testVal);
					// Negate the comparison result if the reverse sort flag is set.
					if (tblEl.reverseSort[col])
						cmp = -cmp;
					// Sort by the second column (team name) if those values are equal.
					if (cmp == 0 && col != 1)
						cmp = compareValues(getTextValue(tblEl.rows[minIdx].cells[1]),
											getTextValue(tblEl.rows[j].cells[1]));
					// If this row has a smaller value than the current minimum, remember its
					// position and update the current minimum value.
					if (cmp > 0) {
						minIdx = j;
						minVal = testVal;
					}
				}

				// By now, we have the row with the smallest value. Remove it from the
				// table and insert it before the current row.
				if (minIdx > i) {
				tmpEl = tblEl.removeChild(tblEl.rows[minIdx]);
				tblEl.insertBefore(tmpEl, tblEl.rows[i]);
				}
			}

			// Make it look pretty.
			makePretty(tblEl, col);

			// Set team rankings.
//			setRanks(tblEl, col, rev);

			// Restore the table's display style.
			tblEl.style.display = oldDsply;

			return false;
			}

			//-----------------------------------------------------------------------------
			// Functions to get and compare values during a sort.
			//-----------------------------------------------------------------------------

			// This code is necessary for browsers that don't reflect the DOM constants
			// (like IE).
			if (document.ELEMENT_NODE == null) {
			document.ELEMENT_NODE = 1;
			document.TEXT_NODE = 3;
			}

			function getTextValue(el) {

			var i;
			var s;

			// Find and concatenate the values of all text nodes contained within the
			// element.
			s = "";
			for (i = 0; i < el.childNodes.length; i++)
				if (el.childNodes[i].nodeType == document.TEXT_NODE)
				s += el.childNodes[i].nodeValue;
				else if (el.childNodes[i].nodeType == document.ELEMENT_NODE &&
						el.childNodes[i].tagName == "BR")
				s += " ";
				else
				// Use recursion to get text within sub-elements.
				s += getTextValue(el.childNodes[i]);

			return normalizeString(s);
			}

			function compareValues(v1, v2) {

			var f1, f2;

			// If the values are numeric, convert them to floats.

			f1 = parseFloat(v1);
			f2 = parseFloat(v2);
			if (!isNaN(f1) && !isNaN(f2)) {
				v1 = f1;
				v2 = f2;
			}

			// Compare the two values.
			if (v1 == v2)
				return 0;
			if (v1 > v2)
				return 1
			return -1;
			}

			// Regular expressions for normalizing white space.
			var whtSpEnds = new RegExp("^\\s*|\\s*$", "g");
			var whtSpMult = new RegExp("\\s\\s+", "g");

			function normalizeString(s) {

			s = s.replace(whtSpMult, " ");  // Collapse any multiple whites space.
			s = s.replace(whtSpEnds, "");   // Remove leading or trailing white space.

			return s;
			}

			//-----------------------------------------------------------------------------
			// Functions to update the table appearance after a sort.
			//-----------------------------------------------------------------------------

			// Style class names.
			var rowClsNm = "alternateRow";
			var colClsNm = "sortedColumn";

			// Regular expressions for setting class names.
			var rowTest = new RegExp(rowClsNm, "gi");
			var colTest = new RegExp(colClsNm, "gi");

			function makePretty(tblEl, col) {

			var i, j;
			var rowEl, cellEl;

			// Set style classes on each row to alternate their appearance.
			for (i = 0; i < tblEl.rows.length; i++) {
			rowEl = tblEl.rows[i];
			rowEl.className = rowEl.className.replace(rowTest, "");
				if (i % 2 != 0)
				rowEl.className += " " + rowClsNm;
				rowEl.className = normalizeString(rowEl.className);
				// Set style classes on each column (other than the name column) to
				// highlight the one that was sorted.
				for (j = 2; j < tblEl.rows[i].cells.length; j++) {
				cellEl = rowEl.cells[j];
				cellEl.className = cellEl.className.replace(colTest, "");
				if (j == col)
					cellEl.className += " " + colClsNm;
				cellEl.className = normalizeString(cellEl.className);
				}
			}

			// Find the table header and highlight the column that was sorted.
			var el = tblEl.parentNode.tHead;
			rowEl = el.rows[el.rows.length - 1];
			// Set style classes for each column as above.
			for (i = 2; i < rowEl.cells.length; i++) {
				cellEl = rowEl.cells[i];
				cellEl.className = cellEl.className.replace(colTest, "");
				// Highlight the header of the sorted column.
				if (i == col)
					cellEl.className += " " + colClsNm;
				cellEl.className = normalizeString(cellEl.className);
			}
			}

			function setRanks(tblEl, col, rev) {

			// Determine whether to start at the top row of the table and go down or
			// at the bottom row and work up. This is based on the current sort
			// direction of the column and its reversed flag.

			var i    = 0;
			var incr = 1;
			if (tblEl.reverseSort[col])
				rev = !rev;
			if (rev) {
				incr = -1;
				i = tblEl.rows.length - 1;
			}

			// Now go through each row in that direction and assign it a rank by
			// counting 1, 2, 3...

			var count   = 1;
			var rank    = count;
			var curVal;
			var lastVal = null;

			// Note that this loop is skipped if the table was sorted on the name
			// column.
			while (col > 1 && i >= 0 && i < tblEl.rows.length) {

				// Get the value of the sort column in this row.
				curVal = getTextValue(tblEl.rows[i].cells[col]);

				// On rows after the first, compare the sort value of this row to the
				// previous one. If they differ, update the rank to match the current row
				// count. (If they are the same, this row will get the same rank as the
				// previous one.)
				if (lastVal != null && compareValues(curVal, lastVal) != 0)
					rank = count;
				// Set the rank for this row.
				tblEl.rows[i].rank = rank;

				// Save the sort value of the current row for the next time around and bump
				// the row counter and index.
				lastVal = curVal;
				count++;
				i += incr;
			}

			// Now go through each row (from top to bottom) and display its rank. Note
			// that when two or more rows are tied, the rank is shown on the first of
			// those rows only.

			var rowEl, cellEl;
			var lastRank = 0;

			// Go through the rows from top to bottom.
			for (i = 0; i < tblEl.rows.length; i++) {
				rowEl = tblEl.rows[i];
				cellEl = rowEl.cells[0];
				// Delete anything currently in the rank column.
				while (cellEl.lastChild != null)
					cellEl.removeChild(cellEl.lastChild);
				// If this row's rank is different from the previous one, Insert a new text
				// node with that rank.
				if (col > 1 && rowEl.rank != lastRank) {
					cellEl.appendChild(document.createTextNode(rowEl.rank));
					lastRank = rowEl.rank;
				}
			}
			}