function toggleInstructions() {
	// Used to "show" or "hide" the instructions to any particular page.  Used
	// in conjunction with the "instructionbox" id
	
	var tblEl = document.getElementById("instructionbox");
	var rowEl = tblEl.rows[1];
	if (rowEl.className == "hidden") 
		rowEl.className = "";
	else
		rowEl.className = "hidden";
	//	return false;
}

function toggleShowHide(myid,showMsg,hideMsg) {
	// Used to "show" or "hide" a div.  Used
	// in conjunction with the "shFilter" and "shInstr" id's
	//
	
	if (myid == "filter") {
		var id = "shFilter";
		var toggleId = "shTogFilter";
		}
	else if (myid == "ColSettings") {
		var id = "shColSets";
		var toggleId = "shTogColSets";
		}		
	else if (myid == "lcGamesToday") {
		var id = "lcGamesToday";
		var toggleId = "shTogGamesToday";
		}		
	else if (myid == "realNames") {
		var id = "shRealNames";
		var toggleId = "shTogRealNames";
		}		
	else {  // default to myid = 'instructions'
		var id = "shInstr";
		var toggleId = "shTogInstr";
		}
	
	var divEl = document.getElementById(id);
	var aEl = document.getElementById(toggleId);
	
	if (divEl.className == "hidden") {
		divEl.className = "";
		aEl.innerHTML = hideMsg;
		}
	else {
		divEl.className = "hidden";
		aEl.innerHTML = showMsg;
		}

	//	return false;
}

function showHideColumn(tableid,toggleid,colClass,showMsg,hideMsg) {
	// Used to "show" or "hide" a column in a table
	//
	// tableid:  id of the table
	// toggleid:  id of the anchor that acts as the toggle switch
	// colClass:  the class of the column (th and td's) that are to be hidden
	// showMsg:  the "show" link text for the toggle (e.g. "Show Real Names")
	// hideMsg:  the "hide" link text for the toggle (e.g. "Hide Real Names")
	
	
	var myToggle = document.getElementById(toggleid);

	var myTable = document.getElementById(tableid);
	var myHeaders = myTable.getElementsByTagName('TH');
	var myCells = myTable.getElementsByTagName('TD');
		
	for (i=1; i<myHeaders.length; i++)
	if (myHeaders[i].className == colClass + " hidden") {
		myHeaders[i].className = colClass;
		}
	else if (myHeaders[i].className == colClass){
		myHeaders[i].className = colClass + " hidden";
		
		}

	for (i=1; i<myCells.length; i++)
	if (myCells[i].className == colClass + " hidden") {
		myCells[i].className = colClass;
		}
	else if (myCells[i].className == colClass) {
		myCells[i].className = colClass + " hidden";
		}
	
	if (myToggle.innerHTML == hideMsg)
		myToggle.innerHTML = showMsg;
	else 
		myToggle.innerHTML = hideMsg;
		
	var standingsHeader = document.getElementById('standingsHeader');
	
	if (standingsHeader) {
		if (myToggle.innerHTML == hideMsg)
			standingsHeader.colSpan = standingsHeader.colSpan + 1;
		else 
			standingsHeader.colSpan = standingsHeader.colSpan - 1;
		}
	//	return false;
}

function help(helpid) 
{
	var r_window = window.open('help_window.cfm?helpid='+helpid,'Help','height=250,width=550,resizable,scrollbars');
	r_window.focus();
	return true;
}

function showHide(myid) {
	// Used to "show" or "hide" a div based on checking a box. 
		
	var divEl = document.getElementById(myid);
	
	if (divEl.className == "hidden") {
		divEl.className = "";
		}
	else {
		divEl.className = "hidden";
		}

	//	return false;
}

function textAreaLength(textbox,maxlength,countID) {
		var mylen = textbox.value.length;
		if (mylen > maxlength) {
			textbox.value = textbox.value.substring(0,maxlength);
			mylen = mbox.value.length;
		 }
		if (mylen > 0.9 * maxlength) {
		document.getElementById(countID).className = 'alert';
		document.getElementById(countID).innerHTML = mylen;
		} else {
		document.getElementById(countID).className = '';
		document.getElementById(countID).innerHTML = mylen;
		}
	}
	
	
	/* To use this function, you need to put "name='tab'" in the anchor tag
		and id the tabs and tab panes apropriately, like id="tab_1" etc. */
	function switchTab(iTab) {
		
		if (!window.myTabs) {
			// set the selected tab (hide the others)
			var myLinks=document.getElementsByTagName("A");
			j=0;
			myTabs = new Array;
			myTabPanes = new Array;
			for (i=0; i<myLinks.length; i++) {
			 	if (myLinks[i].name == "tab") {
					myTabs[j] = document.getElementById('tab_'+j);
					myTabPanes[j] = document.getElementById('tabPane_'+j);
					j++;
				}	
			}
		}
		
		for (i=0; i<myTabs.length; i++) { 
			if (i==iTab) { 
				myTabs[i].className = "tab selected";
				myTabPanes[i].className = "";
			}
			else {
				myTabs[i].className = "tab";
				myTabPanes[i].className = "hidden";
			}
		}
		
		return false;
	}
		

//************************************************************************-->
//* Table Sort Demo                                                      *-->
//*                                                                      *-->
//* Copyright 2002 by Mike Hall                                          *-->
//* Please see http://www.brainjar.com for terms of use.                 *-->
//************************************************************************-->
//* Modifications made by RPM (6 Nov 2006):
//* 1. Table sorting functions were separated from the header of the demo and
//*    placed in this .js file. 
//* 2. Changed setRanks so that the rank of a "tied" row is displayed in the
//*    Rank column (original version left it blank). 
//* 3. Placed a period after the number displayed in the Rank column.
//* 4. Made "setRanks" an option that is set by passing the paramerter "ranks"
//************************************************************************-->

//-----------------------------------------------------------------------------
// sortTable(id, col, rev, ranks, makepretty)
//
//  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.
//  ranks - If true, the "rank" is calculated and displayed in the first column.
//
//  makepretty - If true, call the "makepretty" function.
//
// 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, ranks) {
  // 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);

  
  if (ranks == true) {
  // 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;
  }
  else {
  	v1=v1.toUpperCase();
	v2=v2.toUpperCase();
  }
  // 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;  // took out the period +"."

   // 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;	
  }
  var iplus1;
  if (col == 1)
  	for (i=0; i < tblEl.rows.length;i++) {
		iplus1 = i+1;
		tblEl.rows[i].rank = iplus1;  // took out the period +"."
	}

  // 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;
//    }
  }
}