var clientSideDataGartner = new Array();
 
// Enums for positions in the row array
var csdControlID = 0;
var csdGridID = 1;
var csdRow = 2;
var csdColumn = 3;
var csdGridCellTypeID = 4;
var csdCellValue = 5;
var csdBackgroundColor = 6;
var csdFormElementBackgroundColor = 7;
var csdObjectID = 8;
var csdDerivedFromFormula = 9;
var csdReadOnly = 10;
var csdVisible = 11;
var csdTextColor = 12;
var csdDataTypeID = 13;
var csdCurrencyID = 14;
var csdLanguageID = 15;
var csdMinimumValue = 16;
var csdMaximumValue = 17;
var csdDecimalPlaces = 18;
var csdRequired = 19;
var csdMaxLength = 20;
var csdEvaluationRowStart = 21;
var csdEvaluationRowEnd = 22;
var csdEvaluationColumnStart = 23;
var csdEvaluationColumnEnd = 24;

// Enums For Data Type ID
var dataTypeUnknown = 0;
var dataTypeMoney = 1;
var dataTypeMillionMoney = 2;
var dataTypeNumber = 3;
var dataTypeRadio = 4;
var dataTypeShortText = 5;
var dataTypeLongText = 6;
var dataTypePercent = 7;
var dataTypeMcq = 10;
var dataTypeDate = 12;
var dataTypeCheckbox = 18;
var dataTypeFileUpload = 24;
var dataTypeRadioArray = 25;
var dataTypeCheckboxArray = 26;

// Enums for Grid Cell Type
var gridCellTypeUnknown = 0;
var gridCellTypeLabel = 1;
var gridCellTypeFormElement = 2;
var gridCellTypeRowSum = 3;
var gridCellTypeRowAvg = 7;
var gridCellTypeColSum = 11;
var gridCellTypeColAvg = 15;
var gridCellTypeTypeLink = 16;
var gridCellTypeImageLink = 17;
var gridCellTypeEmpty = 19;
var gridCellTypeAnswerLabel = 20;
var gridCellTypeSelectAll = 21;
var gridCellTypeImage = 22;
var gridCellTypeHtml = 23;
var gridCellTypeGrid = 24;
var gridCellTypeWMV = 25;
var gridCellTypeFlash = 26;
var gridCellTypeChart = 27;

 
function GotoPage(action)
{
  try
  {
     if (!CSDValidateForm()) { return; }
     document.getElementById('SubmitAction').value = action;
     document.getElementById('aspnetForm').submit();
  }
  catch (exception) { AlertError('GotoPage',exception); }
}

function CSDValidateForm()
{
    
    var elem;
    var item;
   
    try
    {
       if (clientSideDataGartner == undefined) { return true; }
       if (clientSideDataGartner.length < 1) { return true; }
       
       // Required fields
       
       for(f=0;f<clientSideDataGartner.length;f++)
       {
  
          item = clientSideDataGartner[f];
           
          elem = document.getElementById(item[csdControlID]);
          
          if (!CSDValidateRequiredField(elem,item))
          {
            return false;
          }
       
       }
   
    }
    catch (exception) { AlertError('CSDValidateForm',exception); }
    return true;
 }
 
 function CSDValidateRequiredField(elem,item)
 {
    var msg = '';
    var elemValue = '';
    var minValue = '';
    var maxValue = '';
    
    try
    {
       if (elem == undefined) { return true; }
       if (item == undefined) { return true; }
       if (item[csdRequired]=='False') { return true; }
 
       if (elem.value == '')
       {
         msg = 'Required field.';
       }
   
       if (IsCalcDataType(item[csdDataTypeID]))
       {
         elemValue = parseFloat(CustomReplace(elem.value,',',''));
         minValue = parseFloat(CustomReplace(item[csdMinimumValue],',',''));
         maxValue = parseFloat(CustomReplace(item[csdMaximumValue],',',''));
         
         if (elemValue >= minValue)
         { 
           if (elemValue <= maxValue)
           {
             return true;
           }
         }
             
         msg = 'Minimum value is ' + item[csdMinimumValue];
         msg +=' and maximum value is ' + item[csdMaximumValue];
             
       }
 
       if (msg == '') { return true; }
          
       elem.focus();
       alert(msg);
       return false;
    
    }
    catch (exception) { AlertError('CSDValidateRequiredItem',exception); }
    return true;
 }
 


function CSDSetFocusOnFirstControl()
{
    var item;
    
    try
    {
       if (clientSideDataGartner == undefined) { return; }
       if (clientSideDataGartner.length < 1) { return; }
       
       for(f=0;f<clientSideDataGartner.length;f++)
       {
          item = clientSideDataGartner[f];
          if (item[csdReadOnly]=='false') { continue; }
          document.getElementById(item[csdControlID]).focus();
          break;
       }
    
    }
     catch (exception) { AlertError('CSDSetFocusOnFirstControl',exception); }
}

 function CSDCalculateGrids()
 {
    var idx = 0;
    var curIdx = -1;
    var lastIdx = -1;
    var item;
    var elem;
  
    try
    {
  
       if (clientSideDataGartner == undefined) { return; }
  
       for(z=0;z<clientSideDataGartner.length;z++)
       {
          item = clientSideDataGartner[z];
 
          if (!IsCalcDataType(item[csdDataTypeID])) { continue; }
          
          elem = document.getElementById(item[csdControlID]);
           
          CSDValidateNumber(elem,
                            item[csdDecimalPlaces],
                            item[csdMinimumValue],
                            item[csdMaximumValue],
                            item[csdRequired],
                            item[csdLanguageID]);
                            
          if (!IsCalcGridCellType(item[csdGridCellTypeID])) { continue; }
          
       //   alert(item[csdRow] + '.' + item[csdColumn]);
          CSDCalculateCellGroup(z);
 
       }
       
    }
    catch (exception) { AlertError('CSDCalculateGrids',exception); }
 }
 
 function CSDValidateCellInSeries(isRow,item,calcItem)
 {
   if (isRow)
   {
      if (item[csdRow] != calcItem[csdRow]) { return false; }
      if (item[csdColumn] < calcItem[csdEvaluationColumnStart]) { return false; }
      if (item[csdColumn] > calcItem[csdEvaluationColumnEnd]) { return false; }
   }
   else
   {
      if (item[csdColumn] != calcItem[csdColumn]) { return false; }
      if (item[csdRow] < calcItem[csdEvaluationRowStart]) { return false; }
      if (item[csdRow] > calcItem[csdEvaluationRowEnd]) { return false; }
   }
   return true;
   
 }
 
 function CSDValidateExcludeCalcControls(calcControlIdx,isRow)
 {
   
    var item;
    var calcItem;
    
    try
    {
    
       calcItem = clientSideDataGartner[calcControlIdx];
    
       for(x=0;x<clientSideDataGartner.length;x++)
       {

          item = clientSideDataGartner[x];
          
          // Exclude the current control
          if (x == calcControlIdx) { continue; }
          
          // Nope, not my grid
          if (item[csdGridID] != calcItem[csdGridID]) { continue; }
          
          // Nope, not same data type
          if (item[csdDataTypeID] != calcItem[csdDataTypeID]) { continue; }
          
          // Nope is not a calculation oriented data type either
          if (IsCalcDataType(item[csdDataTypeID]) == false) { continue; }
          
          // Skip other read only calc cells
          if (IsCalcGridCellType(item[csdGridCellTypeID])) { continue; }
 
          // Are we tabulating rows or columns?
          
          if (!CSDValidateCellInSeries(isRow,item,calcItem)) { continue; }
          
          return true;
        
       }
             
       return false;
     
    }
    catch (exception) { AlertError('CSDValidateExcludeCalcControls',exception); }
 }
  
  
 function CSDCalculateCellGroup(calcControlIdx)
 {
    var totals=parseFloat(0);
    var elem;
    var totalElem;
    var item;
    var thisVal = 0;
    var elementsFound = 0;
    var minus='';
    var calcItem;
    var excludeCalcControls = true;
    
    try
    {
    
       calcItem = clientSideDataGartner[calcControlIdx];
       isRow = IsCalcRow(calcItem[csdGridCellTypeID]);
       
       excludeCalcControls = CSDValidateExcludeCalcControls(calcControlIdx,isRow);
   
       for(x=0;x<clientSideDataGartner.length;x++)
       {

          item = clientSideDataGartner[x];
          
          // Exclude the current control
          if (x == calcControlIdx) { continue; }
          
          // Nope, not my grid
          if (item[csdGridID] != calcItem[csdGridID]) { continue; }
          
          // Nope, not same data type
          if (item[csdDataTypeID] != calcItem[csdDataTypeID]) { continue; }
          
          // Nope is not a calculation oriented data type either
          if (IsCalcDataType(item[csdDataTypeID]) == false) { continue; }
          
          
          // Skip other read only calc cells
          if (excludeCalcControls)
          {
            if (IsCalcGridCellType(item[csdGridCellTypeID])) { continue; }
          }
 
          // Are we tabulating rows or columns?
 
          if (!CSDValidateCellInSeries(isRow,item,calcItem)) { continue; }
          
          // Found an element to calc
          elem = document.getElementById(item[csdControlID]);
 
          minus = '';
          
          if (elem.value.lastIndexOf("-") == 0) { minus='-'; }
          
          thisVal = parseFloat(FormatClean(elem.value));
          
          // Count elements found for possible averaging.  This
          // may need to be moved until after the isNaN check.
          elementsFound++;
          
          if (isNaN(thisVal)) { continue; }
         
          // Increment values total
          
          totals += parseFloat(minus + thisVal);
       }
             
       // Set the total element on screen and reformat it.
       
       totalElem = document.getElementById(calcItem[csdControlID]);
       totalElem.value = totals;
       
       CSDValidateNumber(totalElem,
                         calcItem[csdDecimalPlaces],
                         calcItem[csdMinimumValue],
                         calcItem[csdMaximumValue],
                         calcItem[csdRequired],
                         calcItem[csdLanguageID]);
                        
    }
    catch (exception) { AlertError('CSDCalculateRow',exception); }
 }
  
 
 
 
 function CSDSelectAll(elemID)
 {
    var idx = 0;
    var item;
    var calcItem;
    var elem;
    var isCheckBox = true;
    
    try
    {
       
       idx = CSDGetIndex(document.getElementById(elemID));
      
       if (idx == -1) { return; }
    
       calcItem = clientSideDataGartner[idx];
       
       for(sa=0;sa<clientSideDataGartner.length;sa++)
       {
          item = clientSideDataGartner[sa];
          
          if (item[csdGridID] != calcItem[csdGridID]) { continue; }
          
          switch (item[csdDataTypeID])
          {
             case dataTypeCheckbox: break;
             case dataTypeRadio:    break;
             default:
                       continue;
          }

          if (item[csdControlID] == calcItem[csdControlID]) { continue; }
          
          if (CSDValidateCellInSeries(true,item,calcItem)
             || CSDValidateCellInSeries(false,item,calcItem))
          {
            elem = document.getElementById(item[csdControlID]);
            elem.checked = true;
            SetCheckBox(elem);
            CSDValidateCheckBox(elem,sa);
          }
          
       }
 
    }
    catch (exception) { AlertError('CSDSelectAll',exception); }
 
 }
 
  
 
 function CSDValidateSelf(evt,elem)
 {
    var idx = 0;
    var item;
    try
    {
    
       // Find data attributes for this control.
       idx = CSDGetIndex(elem);
      
       if (idx == -1) { return; }
    
       item = clientSideDataGartner[idx];
       
       switch(parseInt(item[csdDataTypeID]))
       {
         case dataTypeUnknown:
              break;
         
         case dataTypeCheckboxArray:
              break;
         
         case dataTypeRadio:
         
              CSDValidateCheckBox(elem,idx);
              break;
              
         case dataTypeFileUpload:
              break;
              
         case dataTypeCheckbox:
         
              CSDValidateCheckBox(elem,idx);
              break;
              
         case dataTypeShortText:
         
              ValidateFieldLength(elem,item[csdMaxLength]);
              CSDValidateRequiredField(elem,item);
              break;
              
         case dataTypeLongText:
              
              ValidateFieldLength(elem,item[csdMaxLength]);
              CSDValidateRequiredField(elem,item);
              break;
              
         case dataTypeMcq:
              break;
              
         case dataTypeDate:
         
              ValidateShortDate(elem); 
              CSDValidateRequiredField(elem,item);
              break;
              
         default:
         
                CSDValidateNumber(elem,
                                  item[csdDecimalPlaces],
                                  item[csdMinimumValue],
                                  item[csdMaximumValue],
                                  item[csdRequired],
                                  item[csdLanguageID]);
                                  
                CSDValidateRequiredField(elem,item);
                
                CSDCalculateGrids();
             
                break;
       }
   

    }
    catch (exception) { AlertError('CSDValidateSelf',exception); }
 
 }
 
 function CSDValidateNumber(elem,
                            decimalPlaces,
                            minimumValue,
                            maximumValue,
                            required,
                            currencyID)
 {
    var returnValue = false;
    var elemValue = parseFloat(0);
    
    try
    {

      elem.value = FormatNumber(elem.value,
                                currencyID,
                                decimalPlaces);
                                 
    }
    catch (exception) { AlertError('CSDValidateNumber',exception); }
 }
 
 function CSDValidateCheckBox(elem,idx)
 {

    var item;
    var calcItem;

    try
    {
       calcItem = clientSideDataGartner[idx];
     
       for(cb=0;cb<clientSideDataGartner.length;cb++)
       {
          item = clientSideDataGartner[cb];
          
          if (item[csdGridID] != calcItem[csdGridID]) { continue; }
          if (item[csdDataTypeID] != calcItem[csdDataTypeID]) { continue; }
          if (item[csdControlID] == calcItem[csdControlID]) { continue; }
          
          if (CSDValidateCellInSeries(true,item,calcItem)
             || CSDValidateCellInSeries(false,item,calcItem))
          {
            document.getElementById(item[csdControlID]).checked = false;
            SetCheckBox(document.getElementById(item[csdControlID]));
          }
          
       }
       
       return true;
    }
    catch (exception) { AlertError('CSDValidateCheckBox',exception); }
 
 }
 
 function CSDGetIndex(elem)
 {
 
    var returnValue = -1;
   
    try
    {
       for(i=0;i<clientSideDataGartner.length;i++)
       {
          if (clientSideDataGartner[i][csdControlID] == elem.id)
          {
             return i;
          }
       }
    }
    catch (exception) { AlertError('CSDGetIndex',exception); }
    return returnValue;
 
 }
 
  function IsCalcGridCellType(gridCellTypeID)
 {
     switch (parseInt(gridCellTypeID))
     {
        case gridCellTypeUnknown: return false;
        case gridCellTypeLabel: return false;
        case gridCellTypeFormElement: return false;
        case gridCellTypeEmpty: return false;
        case gridCellTypeAnswerLabel: return false;
        case gridCellTypeWMV: return false;
        case gridCellTypeFlash: return false;
        case gridCellTypeChart: return false;
        default:
                 return true;
     }  
 } 
 
   function IsCalcRow(gridCellTypeID)
 {
     switch (parseInt(gridCellTypeID))
     {
        case gridCellTypeRowSum: return true;
        case gridCellTypeRowAvg: return true;
        default:
                 return false;
     }  
 } 
 
 function IsCalcDataType(dataTypeID)
 {
     switch (parseInt(dataTypeID))
     {
        case dataTypeUnknown: return false;
        case dataTypeRadio: return false;
        case dataTypeShortText: return false;
        case dataTypeLongText: return false;
        case dataTypeMcq: return false;
        case dataTypeDate: return false;
        case dataTypeCheckbox: return false;
        case dataTypeFileUpload: return false;
        case dataTypeRadioArray: return false;
        case dataTypeCheckboxArray: return false;
        default:
                 return true;
     }  
 }