var AJAXDebug=0;

var TOP_YES = "Yes";//Yes
var TOP_NO  = "No";//no
var TOP_TRUE  = "true";//true
var TOP_FALSE = "false";//false
var TOP_NONE  = "None";//none
var TOP_ENA = "Enabled";// enabled
var TOP_DIS = "Disabled";// disabled
var TOP_USR = "User";// user
var TOP_OPR = "Operator";// operator
var TOP_ADM = "Administrator";// admin

var requestCtxt = new Object();
requestCtxt.m_fieldMapping = null;
requestCtxt.updateComplete = null;
//
var FieldMapping;
FieldMapping.TYPE_HTML     = 0;
FieldMapping.TYPE_TEXT     = 1;
FieldMapping.TYPE_CHECKBOX = 2;
FieldMapping.TYPE_SELECT   = 3;
FieldMapping.TYPE_RADIO    = 4;
FieldMapping.TYPE_CALLBACK = 5;

var xmlRequestObject;

var Cell;
Cell.ICON       = 0;
Cell.CONTENT    = 1;
Cell.BLANK      = 2;
Cell.HIDDEN		= 3;

function Cell(type, value, align)
{
    this.m_type     = type;
    this.m_value    = value;
    this.m_align    = align;
}

///////////////////////////////////////////////////////////////
//
//Each field has a fieldName and a dataName.
//  The fieldName is used to map the field to the display value on a page,
//  if there is no field name then the field is only accessed on 
//  edits.  In this way a page can iterate through all values returned by
//  the server to populate data for the page, but still skip element that 
//  have no display value that would otherwise cause a "field xxxx not found"
//  message to be displayed.
function FieldMapping( n, d, type, encoder, decoder )
{
    //fieldName used for displaying data
    this.m_fieldName = n;
    //dataName used for updating data
    this.m_dataName = d == null ? n : d;
    this.m_type = type == null  ? FieldMapping.TYPE_HTML : type;
    this.m_encoder = encoder == null ? encodeText : encoder;
    this.m_decoder = decoder == null ? decodeText : decoder;
}

//Convenience object that "extends" FieldMapping with specific checkbox behaviors pre-defined.
function CheckboxMapping( n, d )
{
	return new FieldMapping(n, d, FieldMapping.TYPE_CHECKBOX, encodeCheckbox, decodeBoolean);
}

//Convenience object that "extends" FieldMapping with specific radio button behaviors pre-defined.
function RadioMapping( n, d )
{
	return new FieldMapping(n, d, FieldMapping.TYPE_RADIO, encodeRadio, decodeRadio);
}

/////////////////////////////////////
//
function encodeSetValue( text )
{
   if( text == null )
     return "";
   else
   {
     var newUrl = text.replace(/\\/g, "\\\\" );
     newUrl = newUrl.replace(/:/g, "\\:" );
	 //  ConnectionHandler's tokenizer uses:  (),=&?
     newUrl = newUrl.replace(/,/g, "\\," );
     newUrl = newUrl.replace(/\(/g, "\\(" );
     newUrl = newUrl.replace(/\)/g, "\\)" );
     newUrl = newUrl.replace(/\=/g, "\\=" );
     newUrl = newUrl.replace(/&/g, "\\&" );
     newUrl = newUrl.replace(/\?/g, "\\?" );

     return encodeURIComponent(newUrl);
   }
}

////////////////////////////////////
//  Function to encode text fields.
function encodeText( formElement )
{
    return encodeSetValue( formElement.value );
}

////////////////////////////////////
//  Function to encode checkbox's as 1=true or 0=false.
function encodeCheckbox( formElement )
{
    return formElement.checked ? "1" : "0";
}

////////////////////////////////////
//  Function to encode checkbox's as 1=true or 0=false.
function encodeSelect( formElement )
{
    if( formElement.selectedIndex >= 0 )
        {
        //alert("call to encodeSelect: " + formElement.options[ formElement.selectedIndex ].value);
        return formElement.options[ formElement.selectedIndex ].value;
        }
    else
        return '';
}

////////////////////////////////////
//  Function to encode checkbox's as 1=true or 0=false.
function encodeRadio( formElement )
{
    for( var i=0 ; i<formElement.length ; ++i )
    {
        if( formElement[i].checked )
            return formElement[i].value;
    }
    //
    return '';
    //return formElement.options[ formElement.selectedIndex ].value;
}

////////////////////////////////////
//  Function to encode checkbox's as 1=true or 0=false.
function decodeSelect( fieldMapping, value )
{
    var selectedIndex = -1;
    var elem = document.getElementById( fieldMapping.m_fieldName );
    if( elem != null & elem.options != null )
    {
        for( var i=0 ; i<elem.options.length ; ++i )
        {
            if( elem.options[i].value == value )
            {
                selectedIndex = i;
                break;
            }
        }
        //
        elem.options.selectedIndex = selectedIndex;
    }
}

///////////////////////////////////
//  Default decoder.
function decodeText( fieldMapping, value )
{   
    var myVal = value;
    if (value == null) myVal = "";
    
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, myVal );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, myVal );
       //appendChild( fieldMapping.m_fieldName, myVal );
    else if( fieldMapping.m_type == FieldMapping.TYPE_SELECT )
       setSelectedOption( fieldMapping.m_fieldName, myVal );
}

///////////////////////////////////
//  Decode Encryption string values
function decodeEncryption ( fieldMapping, value )
{
    var myVal = value;
    if (value == null) myVal = "";
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, myVal );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, myVal );
    else if( fieldMapping.m_type == FieldMapping.TYPE_CHECKBOX )
    {   
        var bVal = "1"; //true
        if (myVal == "NONE" || myVal == "0" || myVal == "") bVal = "0"; //false
        setCheckbox( fieldMapping.m_fieldName, bVal );   
    }
}


///////////////////////////////////
// 
function decodeBooleanNoneYes( fieldMapping, value )
{
    //alert("Decode bool yes/no: " + value );
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, value == true ? TOP_YES : TOP_NONE );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, value == true ? TOP_YES : TOP_NONE );
       //appendChild( fieldMapping.m_fieldName, value == true ? "Yes" : "None" );
    else if( fieldMapping.m_type == FieldMapping.TYPE_CHECKBOX )
       setCheckbox( fieldMapping.m_fieldName, value );
}


///////////////////////////////////
//  Default decoder for boolean parameters.
function decodeBoolean( fieldMapping, value )
{
    //alert("Decode bool yes/no: " + value );
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, value == true ? TOP_YES : TOP_NO );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, value == true ? TOP_YES : TOP_NO );
       //appendChild( fieldMapping.m_fieldName, value == true ? "Yes" : "No" );
    else if( fieldMapping.m_type == FieldMapping.TYPE_CHECKBOX )
       setCheckbox( fieldMapping.m_fieldName, value );
}

///////////////////////////////////
//  Default decoder for boolean parameters.
function decodeBooleanTrueFalse( fieldMapping, value )
{
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, value == true ? TOP_TRUE : TOP_FALSE );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, value == true ? TOP_TRUE : TOP_FALSE );
       //appendChild( fieldMapping.m_fieldName, value == true ? "true" : "false" );
    else if( fieldMapping.m_type == FieldMapping.TYPE_CHECKBOX )
       setCheckbox( fieldMapping.m_fieldName, value );
//
}

///////////////////////////////////
//  Default decoder for boolean parameters.
function decodeBooleanEnabledDisabled( fieldMapping, value )
{
    if( fieldMapping.m_type == FieldMapping.TYPE_TEXT )
       setTextField( fieldMapping.m_fieldName, value == true ? TOP_ENA : TOP_DIS );
    else if( fieldMapping.m_type == FieldMapping.TYPE_HTML )
       setDiv( fieldMapping.m_fieldName, value == true ? TOP_ENA : TOP_DIS );
       //appendChild( fieldMapping.m_fieldName, value == true ? "Enabled" : "Disabled" );
    else if( fieldMapping.m_type == FieldMapping.TYPE_CHECKBOX )
       setCheckbox( fieldMapping.m_fieldName, value );
}

///////////////////////////////////
//  
function decodeRadio( fieldMapping, value )
{
    if( value != null ) 
    {
        var elemList = document.getElementsByName( fieldMapping.m_fieldName );
        if( elemList != null )
        {
            for( var i=0 ; i<elemList.length ; ++i )
            {
               if( elemList[i].value == value )
               {
                    elemList[i].checked = "true";
                    break;
               }
            }
         }
     }
}

//  This can be refactored into waitWithCallback
function setFieldListFromXML(xmlDoc)
{
    if (xmlDoc==null) 
    {
        //Request failed
        //TODO: disable screen?
    }
    else
    {
        //  Set the fields. 
        for( var i=0 ; i<fieldList.length ; ++i )
        {
            var dataName = fieldList[i].m_dataName;
            var paramValue = getXMLValue( xmlDoc, dataName ) ;
            //
            if( fieldList[i].m_type == FieldMapping.TYPE_CALLBACK ) 
                dataCallback( fieldList[i], paramValue, xmlDoc );
            else
                fieldList[i].m_decoder( fieldList[i], paramValue );
        } 
    }  //end status==ok block
    //
    hideElement( 'progressScreen' );
    showInlineElement( 'contentArea' );
}    


///////////
//  Function to generate progress image. 
//
function formatProgressPanel()
{
 // var txt = '<br><br><table id="progressTable" style="text-align: left; width: 585px; height: 77px;" border="0" cellpadding="2" cellspacing="2"><tbody><tr align="center"><td style="vertical-align: top;"><h1>Please Wait...</h1></td></tr><tr align="center"><td style="vertical-align: top;"><img alt="Please wait" src="images/progress.gif" style="width: 111px; height: 14px;"><br></td></tr></tbody></table>';
  var txt = '<br><br><table id="progressTable" class="progressTable" ><tbody><tr align="center"><td class="progressMsg">Please Wait...</td></tr><tr align="center"><td style="vertical-align: top;"><img alt="Please wait" src="images/progress.gif" style="width: 111px; height: 14px;"><br></td></tr></tbody></table>';
  document.write( txt );
}

///////////////////////////////////////////////////////////////////
//
//  Show progress image in place of it the content panel
function showProgressPanel()
{
    hideElement( 'contentArea' );
    showProgressBlockElement('progressScreen');
}

///////////////////////////////////////////////////////////////////
//  Convenience method for showing Progress element even if form already loaded.
function showProgressBlockElement( elemName ) {
    var elem = document.getElementById( elemName );
    if( elem == null || elem['style'] == null ){}
        //alert('Missing element ' + elemName );
    else
        // var txt = '<br><br><table id="progressTable" style="text-align: left; width: 585px; height: 77px;" border="0" cellpadding="2" cellspacing="2"><tbody><tr align="center"><td style="vertical-align: top;"><h1>Please Wait...</h1></td></tr><tr align="center"><td style="vertical-align: top;"><img alt="Please wait" src="images/progress.gif" style="width: 111px; height: 14px;"><br></td></tr></tbody></table>';
          var txt = '<br><br><table id="progressTable" class="progressTable" ><tbody><tr align="center"><td class="progressMsg">Please Wait...</td></tr><tr align="center"><td style="vertical-align: top;"><img alt="Please wait" src="images/progress.gif" style="width: 111px; height: 14px;"><br></td></tr></tbody></table>';

		
        elem.innerHTML = txt;
        elem.style.display = 'block';
}


///////////////////////////////////////////////////////////////////
//
//  Show progress image in place of it the content panel
function showContentPanel()
{
    hideElement( 'progressScreen' );
    showInlineElement( 'contentArea' );
}

///////////////////////////////////////////////////////////////////
//
function loadData( renderPageCallback )
{
    var reqUrl = 'data?get=';
    for( var i=0 ; i<fieldList.length ; ++i )
       reqUrl += fieldList[i].m_dataName + ',';
    loadDataURL( reqUrl, renderPageCallback );
 }
 
 //////////////////////////////////////////////////
 //
 function sendPost( reqUrl, postData, renderPageCallback )
 {
    if( renderPageCallback != null )
        document.chainedCallback = renderPageCallback;
    else
        document.chainedCallback = setFieldListFromXML
    //
    loadXMLDocument( reqUrl, waitWithCallback, postData );
 }
 
 //////////////////////////////////////////////////
 //
 function loadDataURL( reqUrl, renderPageCallback )
 {
    if( renderPageCallback != null )
        document.chainedCallback = renderPageCallback;
    else
        document.chainedCallback = setFieldListFromXML
    //
    loadXMLDocument( reqUrl, waitWithCallback );
 }

///////////////////////////////////////////////////////////////////
//
function formatPostRequest( formElement )
{
    var req = "";
    if( formElement.elements.length > 1 )
    {
        var elem = formElement.elements[0];
        req = elem.name + ":" + encodeSetValue( elem.value );
        //
        for( var i=1 ; i<formElement.elements.length ; ++i )
        {
            elem = formElement.elements[i];
            req += ',' + elem.name + ":" + encodeSetValue( elem.value );
        }
    }
    return req;
}

/////////////////////////////////////////////////////////////////
//
function formatPostRequestForFields( formElement, fieldList )
{
    var req = "";
    var count = 0;
    for( var i=0 ; i<fieldList.length ; ++i )
    {
        if( fieldList[i] == null )
            continue;
        var field = fieldList[i];
        var encoder = fieldList[i].m_encoder;
        //
        var formElem = formElement[field.m_fieldName];
        //
        if( formElem != null && encoder != null )
        {
            if( count++ != 0 )
                req += ",";
            req += field.m_dataName + ":" + encoder( formElem );
        }
    }
    return req;
}

////////////////////////////////////////////////////////////////////
//
function getXMLValue( xmlDoc, elementName )
{
    //alert("getXMLValue( xmlDoc, " + elementName + ");");
    var rtn = "";
    var i;
    //
    if( xmlDoc == null || xmlDoc.childNodes.length == 0 )
    {
      //alert("Received bad XML document.");
    }
    else 
    {
       var elements = xmlDoc.getElementsByTagName( elementName );
       //
       if( elements != null && elements.length > 0  && elements[0].childNodes != null  )
       {
           if( elements[0].childNodes.length == 0 )
               return null;
           else if( elements[0].childNodes[0].nodeType == 3){
                var j = elements[0].childNodes.length;
                for (i = 0; i < j; i++){
                    rtn = rtn + elements[0].childNodes[i].nodeValue;
                }
                //Fix for FireFox. Long returns are broken up into 4096 byte child nodes.  IE is all in one.
                //alert("rtn len=" + rtn.length + "ChildNode count=" + j + "\n" );
           }
           else {
               rtn = elements[0];
		   }
       }
    }
   return rtn
 }


/////////////////////////////////////////////////////////////////////////
//
//  Requests the XML document.
//
//Lets load the WebPage defined by url ( output should be xml )r
//If we are using IE then we will use microsoft ActiveX Object, there are
//two microsoft objects we can try. If the first fails, move to second one.
//if not IE then we will use the defined JS object XMLHttpRequest().
//
function loadXMLDocument( url, callback, postData )
{
    loadXMLDocument__( url, callback, postData, true );
}
function loadXMLDocumentSynchronous( url )
{
    loadXMLDocument__( url, function (){}, null, false );
}
function loadXMLDocument__( url, callback, postData, asynchronous )
{
    var xDoc;
    //
    if( window.XMLHttpRequest ) 
    {
        xmlRequestObject = new XMLHttpRequest();
    } 
    else if( window.ActiveXObject )
    //     if( window.ActiveXObject )  
    {
        try 
        {
            xmlRequestObject = new ActiveXObject("Msxml2.XMLHTTP");
           // alert("XMLHttpRequest is executed"); 
        }
        catch ( e ) 
        {
            try 
            {
                xmlRequestObject = new ActiveXObject("Microsoft.XMLHTTP");
            }
            catch ( E ) 
            {    
            }
        }
     }
     //
     if( xmlRequestObject ) 
     {
         xmlRequestObject.onreadystatechange = callback;
         xmlRequestObject.open("POST", url, asynchronous );
         if( postData == null )
             postData = '';
         xmlRequestObject.setRequestHeader("Content-Type", "application/x-www-form-urlencoded" );
         xmlRequestObject.send( postData );
     }
}


function getXMLTagByName( xmlDoc, name )
{
    var tagList = xmlDoc.getElementsByTagName( name );
    var rtn = null;
    //
    if( tagList.length > 0 )
        rtn = tagList[0];
    return rtn;
}

function setTextField( fieldId, value )
{
    var elem = document.getElementById( fieldId );
    if( elem != null && elem.value != undefined )
       {
           if (value == null)
               elem.value = '';
           else
              elem.value = value;       
       } 
}

function setDiv( fieldId, value )
{

    var elem = document.getElementById(fieldId);
    
        //this is the element in the HTML page
    if (elem != null)

    {

	   if ("innerText" in elem && "outerHTML" in elem)
	   {
	    	elem.innerText= value;
	    	elem.textContent=value;
           }
	   else	
	  {
	        elem.innerHTML = value;
          }
	}
}

function setCheckbox( fieldId, value ) {
    var val = false;
    if( value != undefined )
       val = my_trim(value) == "0" ? false : true;

    var elem = document.getElementById( fieldId );
    if( elem != null && elem.checked != undefined )
      elem.checked = val == "0" ? false : true;
}

function my_trim(str)
{
	if (str == null || str==undefined )
	{
		return "";
	} 
	str = str.replace(/^\s*/gi, "");
	str = str.replace(/\s*$/gi, "");
	return str;
} 



function setRadio( formElement, fieldName, value ) {
    var val = false;
    if( value != null ) 
    {
      for( var i=0 ; i<formElement.elements.length ; ++i )
      {
         var elem = formElement.elements[i];
         if( elem.name == fieldName && elem.value == value )
         {
              elem.checked = "true";
              break;
         }
      }
    }
}

function setSelectedOption( name, value ) {
    var selElement = document.getElementById( name );
    //
    if( selElement != null && selElement.options  ) {
        for( var i=0 ; i<selElement.options.length ; ++i ) {
            if( selElement.options[i].value == value ) {
                selElement.options[i].selected = true;
                break;
            }
        }
    }
}

function getSelectedRadio( formElement, fieldName )
{
    for( var i=0 ; i<formElement.elements.length ; ++i )
    {
       var elem = formElement.elements[i];
       if( elem.name == fieldName && elem.checked )
       {
            return elem;
       }
    }
    return null;
}


//  Generic method to show errors on settings pages.
function showErrorMessage( msg )
{
    alert(" Error: " + msg );
}

// Convenience method for setting the innterHtml of a message 
// element and displaying it.
function showBlockMessage( elementName, msg ) {
    var elem = document.getElementById( elementName );
    if( elem != null ) {
        elem.innerHTML = msg;
        elem.style.display = 'block';
    }
    else {
        alert('Cannot find element: ' + elementName );
    }
}

function showInlineMessage( elementName, msg ) {
    var elem = document.getElementById( elementName );
    if( elem != null ) {
        elem.innerHTML = msg;
        elem.style.display = 'inline';
    }
    else {
        alert('Cannot find element: ' + elementName );
    }
}

//  Convenience method for hiding elements (such as error messages).
function hideElement( elemName ) {
    var elem = document.getElementById( elemName );
    if( elem == null || elem['style'] == null ){}
        //alert('Missing element ' + elemName );
    else
        elem.style.display = 'none';
}

//  Convenience method for showing elements.
function showBlockElement( elemName ) {
    var elem = document.getElementById( elemName );
    if( elem == null || elem['style'] == null ){}
        //alert('Missing element ' + elemName );
    else
        elem.style.display = 'block';
}

//  Convenience method for showing elements.
function showInlineElement( elemName ) {
    var elem = document.getElementById( elemName );
    if( elem == null || elem['style'] == null ){}
        //alert('Missing element ' + elemName );
    else
        elem.style.display = 'inline';
}



function isValidatePort( elemId ) 
{
    var elem = document.getElementById( elemId );
    if( elem == null ) {
        alert('Element (' + elemId + ') not found.');
        return 1;
    }
    else
    {
        var portNum = elem.value;
        return portNum > 0 && portNum <= 65535 ? 0 : 1;
    }
}

////////////////////////////////////////////////////////////////////
//
function ipmiPrivToName( type )
{
    var name = "Unknown";
    if( type == 15 )
        name = TOP_NONE;//None 
    if( type == 2 )
        name = TOP_USR;//User
    else if( type == 3 )
        name = TOP_OPR//"Operator";
    else if( type == 4 )
        name = TOP_ADM//"Administrator"; 
    return name;
}


function showUpdateArea()
{
    hideElement( 'contentArea' );
    hideElement('progressScreen');
    showInlineElement('updateArea');
}

  
/**
 * Callback used with loadXMLDocument.  This function will
 * be called each time the xmlRequestObject's readyState changes.
 * When the readyState is 4, indicating that processing is 
 * complete, the status is checked.  If the status is ok then
 * the method document.chainedCallback will be called.  document.chainedCallback
 * should be defined at the page level prior to calling loadXMLDocument.
 */
function waitWithCallback()
{
    //Only execute for state "loaded", all other states have 
    //  no processing.
    if (xmlRequestObject.readyState == 4)
    {
        // only if "OK"
        if (xmlRequestObject.status == 200 )
        {
            var xmlDoc = xmlRequestObject.responseXML;
            var reqStatus = getXMLValue( xmlDoc, 'status' );
            if( reqStatus != 'ok' )
            {
                var message = getXMLValue( xmlDoc, 'message' );
                //alert(" Request failed: " + message );
                //If we fail perform the callback with a null doc 
                //  to signal the chainedCallback that the server'
                //  did not recognize the request
                document.chainedCallback(null);
            }
            else
            {
                //It might be wise at somepoint to implement 
                //  chainedCallback as a stack to avoid accidentally
                //  stepping on a callback by overwriting it with
                //  a value that hasn't been called back yet.  This
                //  would introduce substantial complexity though...
                document.chainedCallback(xmlDoc);
                if( requestCtxt.updateComplete != null)
                {
                    requestCtxt.updateComplete( requestCtxt, xmlDoc );
                }
            }
        }
        else if( xmlRequestObject.status == 401 )
        {
            document.location = "/login.html";
        }
        else
        {
            //showErrorMessage(" Could not retrieve data from server ( status=" +
            //                                 xmlRequestObject.status + ", " + xmlRequestObject.statusText + ")" );
            showContentPanel();
        }
    }
} //end of waitWithCallback

/**
 * Rows alternate styles, this method provides a mechanism
 * for changing the style based on the row index.
 */
function getStyleForRow(tableRowIndex) {
    return (tableRowIndex % 2 == 0) ? 'data-area-canvas-odd' : 'data-area-canvas';
}
  
function insertBlankCell(tr, cellIndex)
{
    var cell = tr.insertCell(cellIndex);
    cell.className=getStyleForRow(tr.rowIndex);
    cell.innerHTML='<img src="images/blank.gif">';
}


function populateCell(cell, tableRowIndex, innerHTML, align, cellType) 
{
    cell.className=getStyleForRow(tableRowIndex);
    cell.vAlign='middle';
    if (align !=null)
    {
    	cell.align=align;
    }
    if (cellType == null) 
    {
    	//Don't interpret no type as unknown, default to content.
    	cellType = Cell.CONTENT;
    }
    switch (cellType)
    {
    	case Cell.ICON:
			cell.innerHTML="<img src=" + innerHTML + ">";
    		break;
		case Cell.CONTENT:
			cell.innerHTML = (innerHTML == '    ') ? '[N/A]' : innerHTML;
			break
		case Cell.BLANK :
			cell.innerHTML='<img src="images/blank.gif">';
			break;
		case Cell.HIDDEN :
			cell.innerHTML='<span style="display:none;">' + innerHTML + '</span>'
			break;
		default:
            showErrorMessage("Unknown type for cell, cell - " + celltype);
            break;
    }
}

/**
 * Submit a request for data to the server and call
 * refreshDataCallback when the response arrives.
 */
function refreshData(data) 
{
    document.chainedCallback = refreshDataCallback;
    loadXMLDocument('data?get=' + data, waitWithCallback);
}



function appendTableRow(table,row)
{
    var aTable = document.getElementById(table);
    if (null ==  aTable)
		return;
		
    var newRowIndex = aTable.rows.length;
        
    //doesn't seem to be a way to set style="height: 1px;" for blank.gif rows...
    //  but it also doesn't seem to affect table layout.
    var tr = aTable.insertRow(newRowIndex);
    for (i = 0; i < row.length; i++)
    {
		cell = tr.insertCell(i);
    	populateCell(cell, newRowIndex, row[i].m_value, row[i].m_align, row[i].m_type);
	}
}

function clearTableRows(tableName, startRow, endRow) 
{
	aTable = document.getElementById(tableName);
	if (aTable == null || aTable.rows.length==0)
	{
		//Nothing to do.
		return;
	}
	if (startRow == null) 
	{
		startRow = 0;
	}
	if (endRow == null || endRow > aTable.rows.length) 
	{
		endRow = aTable.rows.length;
	}
	//Delete at the starting point until 
	//  the number of rows between start and end 
	//  are gone. 
	for (var x=startRow; x < endRow; x++)
	{
		aTable.deleteRow(startRow);
	}
	
}

//Given a select control and a delimitted string convert the string into
//options for the select control.
function delimValueToOptions(selectControl, value, delim)
{
	//Clear any existing options
	while (selectControl.options.length > 0)
	{
		selectControl.remove(0);
	}
	if (value == null)
	{
		return;
	}
	var valueArray = value.split(delim);
	for (var optionIndex=0; optionIndex<valueArray.length; optionIndex++)
	{
		var oneOption = new Option();
		oneOption.text = valueArray[optionIndex];
		try {
			selectControl.add(oneOption, null);
		} catch (ex) {
			//IE only
			selectControl.add(oneOption);
		}
	}
}

//Given an select control, convert it's options convert to a delimitted string
function optionsToDelimValue(selectControl, delim)
{
	var options = selectControl.options;
	var delimString = "";
	if (options == null)
	{
		return "";
	}
	for (var optionIndex=0; optionIndex<options.length; optionIndex++)
	{
		delimString = delimString + options[optionIndex].text + delim;
	}
	//Drop the last delimitter
	delimString = delimString.substring(0, (delimString.length - 1));
	return delimString;

}
    
	function HTMLEncode( text )
	{
		if ( typeof( text ) != "string" ) text = text.toString();
		text = text.replace(/&/g, "&amp;");
		text = text.replace( /</g, "&lt;");
		text = text.replace(/>/g, "&gt;");
		return text ;
	}