  //================================================
  // Preview Button on Notification Template
  // targetAction: Basically goes to the EditCustomerAction.getPreview method
  //               and parses the message to be displayed
  // strAction: Basically goes to EditCustomerAction.setTemplate which committs
  //            the chnages made by the user
  //================================================
  function ButtonPreview(objForm, strAction, targetAction, PreviewButtonName)
  {
   var winPopUp=window.open(strAction, 'Preview', 'toolbar=0,scrollbars=1,width=500,height=400');
   objForm.action = targetAction;
   objForm.target = 'Preview';
   objForm.submit();
   objForm.target = '';
   winPopUp.focus();
  }
  
  function ButtonSubmitAndOpenWindow(objForm, strAction, targetAction)
  {
   objForm.action = targetAction;
   objForm.submit();
  
   var winPopUp=window.open(strAction, 'Preview', 'toolbar=0,resizable=yes,scrollbars=2,width=500,height=400');
   winPopUp.focus();
  }

  //================================================
  // ButtonSubmit
  //================================================
  function ButtonSubmit(objForm,strAction)
  {
          objForm.action=strAction;
          objForm.submit();
  }

  // ============
  // HrefSubmit
  //===========
  function HrefSubmit(objForm,strAction)
  {
          objForm.action=strAction;
          objForm.submit();
  }
  
  //====================================
  //HighlightAndSubmit - combined call
  // to HighlightAllSelectedDevices and
  // HrefSubmit
  //====================================
  function HighlightAndSubmit(which, objForm, strAction)
  {
    HighlightAllSelectedDevices(which);
    HrefSubmit(objForm, strAction);
  }

  //mshah On Demand Report period change
  function ReportPeriodChange(objForm,strAction)
  {
          objForm.action=strAction + "&reportPeriod=" + objForm.selectedPeriod.value;
          objForm.submit();
  }

  //================================================
  // ButtonRedirect
  //================================================
  function ButtonRedirect(strAction)
  {
          location=strAction;
  }

  //================================================
  // OpenWindow
  //================================================
  function OpenWindow(strFileName)
  {
          var iWidth=625;
          var iHeight=500;
          var iLeftPos=screen.width/2 - (iWidth/2);
          var iTopPos=screen.height/2 - (iHeight/2);
          var winPopUp=window.open(strFileName,'New',"toolbar=1,location=1,directories=1,status=1,menubar=1,scrollbars=yes,resizable=1,width="+iWidth+",height="+iHeight+",left="+iLeftPos+",top="+iTopPos);
          winPopUp.focus();
  }

  //================================================
  // OpenHelp
  //================================================
  function OpenHelp(strFileName)
  {
          var iWidth=725;
          var iHeight=700;
          var iLeftPos=screen.width/2 - (iWidth/2);
          var iTopPos=screen.height/2 - (iHeight/2);
          help=window.open(strFileName,'Help',"toolbar=0,location=0,directories=0,status=0,menubar=0,scrollbars=1,resizable=1,width="+iWidth+",height="+iHeight+",left="+iLeftPos+",top="+iTopPos);
          help.focus();
  }
  //================================================
  // OpenPreview
  //================================================
  function OpenPreview(strFileName)
  {
          var iWidth=625;
          var iHeight=500;
          var iLeftPos=screen.width/2 - (iWidth/2);
          var iTopPos=screen.height/2 - (iHeight/2);
          var winPopUp=window.open(strFileName,'Help',"toolbar=0,location=0,directories=0,status=0,menubar=0,scrollbars=1,resizable=1,width="+iWidth+",height="+iHeight+",left="+iLeftPos+",top="+iTopPos);
          winPopUp.focus();
  }

  //================================================
  // processSelectionGroupAndSelectionGroupA
  //================================================
  function processSelectionGroupAndSelectionGroupA(theForm,theField,thFieldA){
          if (theForm.chkAll.checked == true){
                  checkAll(theForm, theField);
                  checkAll(theForm, theFieldA);
          }
          else if (theForm.chkAll.checked == false){
                  unCheckAll(theForm, theField);
                  unCheckAll(theForm, theFieldA);
          }
  }

  /**
   * Takes:
   * theForm: form name
   * theField:multiselectbox which needs to be checked/unchecked
   * checkbox:document[0].form.checkboxname
   */
  //================================================
  // processSelectionCheckbox
  //================================================
  function processSelectionCheckbox(theForm,theField,checkbox){
          if (checkbox.checked == true){
                  checkAll(theForm, theField);
          }
          else if (checkbox.checked == false){
                  unCheckAll(theForm, theField);
          }
  }

  //================================================
  // processSelection
  //================================================
  function processSelection(theForm,theField){
          if (theForm.chkAll.checked == true){
                  checkAll(theForm, theField);
          }
          else if (theForm.chkAll.checked == false){
                  unCheckAll(theForm, theField);
          }
  }

  //================================================
  // checkAll
  //================================================
  function checkAll(theForm, theField) {
      for (i=0,n=theForm.elements.length;i<n;i++){
         if(theForm.elements[i].name!=undefined){
          if (theForm.elements[i].name.indexOf(theField) !=-1){
            theForm.elements[i].checked = true;
          }
         }
      }
  }

  //================================================
  // unCheckAll
  //================================================
  function unCheckAll(theForm, theField){
          for (i=0,n=theForm.elements.length;i<n;i++){
            if(theForm.elements[i].name!=undefined){
                if (theForm.elements[i].name.indexOf(theField) != -1){
                    theForm.elements[i].checked = false;
                }
            }
          }
  }

  //========
  // Unselect CheckAll box when at least one check row is unselected and,
  // Select CheckAll box when all rows are checked
  //==========
  
	function reflectSelection(theForm, theField)
	{
		var uncheckedFound = false;
		for (i=0,n=theForm.elements.length;i<n && !uncheckedFound;i++){
			if(theForm.elements[i].name!=undefined){
				if (theForm.elements[i].name.indexOf(theField) != -1){
					if(theForm.elements[i].checked == false){
						uncheckedFound = true;
					}
				}
			}
		}
		if (uncheckedFound){
			theForm.chkAll.checked = false;
		}
		else{
			theForm.chkAll.checked = true;
		}
	}
	
	/**
	* THis method should be use instead of reflectSelection that hard codes the
	* name of the field. Aldeep said there is no time for changing all the jsps 
	* now. However this sould be done in the future as this method is more flexible
	*/	
	function reflectSelection2(theForm, theField, target)
	{
		var uncheckedFound = false;
		for (i=0,n=theForm.elements.length;i<n && !uncheckedFound;i++){
			if(theForm.elements[i].name!=undefined){
				if (theForm.elements[i].name.indexOf(theField) != -1){
					if(theForm.elements[i].checked == false){
						uncheckedFound = true;
					}
				}
			}
		}
		if (uncheckedFound){
			target.checked = false;
		}
		else{
			target.checked = true;
		}
	}	
	
	/**
	* This function disable/enable 'Edit Device(s)', 'Add Service(s)', and 'Finish'
	* buttons on import_asset_unmanaged_devices.jsp based on selected checkboxes
	*/
	function UnmanagedAssetDevicesSelection(theForm, theField)
	{
		var checkedFound = false;
		for (i=0,n=theForm.elements.length;i<n && !checkedFound;i++){
			if(theForm.elements[i].name!=undefined){
				if (theForm.elements[i].name.indexOf(theField) != -1){
					if(theForm.elements[i].checked == true){
						checkedFound = true;
						break;
					}
				}
			}
		}
		if (checkedFound){
			setElementStyleClass("AssetEditDevices", "Button");
			setElementStyleClass("AssetAddServices", "Button");
			setElementStyleClass("AssetFinish", "Button");
			setElementStyleClass("bAssetEditDevices", "Button");
			setElementStyleClass("bAssetAddServices", "Button");
			setElementStyleClass("bAssetFinish", "Button");
			document.getElementById("AssetEditDevices").disabled=false;
			document.getElementById("AssetAddServices").disabled=false;
			document.getElementById("AssetFinish").disabled=false;
			document.getElementById("bAssetEditDevices").disabled=false;
			document.getElementById("bAssetAddServices").disabled=false;
			document.getElementById("bAssetFinish").disabled=false;
		}
		else{
			setElementStyleClass("AssetEditDevices", "disabledButton");
			setElementStyleClass("AssetAddServices", "disabledButton");
			setElementStyleClass("AssetFinish", "disabledButton");
			setElementStyleClass("bAssetEditDevices", "disabledButton");
			setElementStyleClass("bAssetAddServices", "disabledButton");
			setElementStyleClass("bAssetFinish", "disabledButton");
			document.getElementById("AssetEditDevices").disabled=true;
  			document.getElementById("AssetAddServices").disabled=true;
  			document.getElementById("AssetFinish").disabled=true;
  			document.getElementById("bAssetEditDevices").disabled=true;
  			document.getElementById("bAssetAddServices").disabled=true;
  			document.getElementById("bAssetFinish").disabled=true;
		}
	}

  //================================================
  // JumpTo
  //================================================
  function JumpTo(objForm , theSelect)
  {
          objForm.Offset.value = theSelect.selectedIndex
          objForm.submit();
  }

  //================================================
  // GoTo
  //================================================
  function GoTo(objForm , offset)
  {
          objForm.Offset.value = offset
          objForm.submit();
  }

  //================================================
  // SortCol
  //================================================
  function SortCol(objForm , sort, order)
  {
          objForm.sort.value = sort
          objForm.order.value = order
          objForm.submit();
  }

  //================================================
  // StartAt
  //================================================
  function StartAt(objForm , start)
  {
          objForm.Start.value = start
          objForm.Offset.value = 0
          objForm.submit();
  }

    //================================================
  // GetCalendar
  // This fuction is called to make a request to render a popup calendar, in
  // the case when there are more than one form in the HTML
  // The onus is on the user to pass the idx of the for in the DOM model
  // Parameters-
  //================================================

  function GetCalendar(title, formId) {
    var iWidth=196;
    var iHeight=210;
    if( formId != null && formId !='undefined'){
      var strFileName='/calendarAction.do?formId=' +formId;
    }else{
    var strFileName='/calendarAction.do';
    }
    top.calendarWindow = window.open(strFileName, "Calendar","toolbar=0,location=0,directories=0,status=0,menubar=0,scrollbars=0,resizable=0,width="+iWidth+",height="+iHeight+",left=100,top=100")
    top.calendarWindow.focus();
  }

  ////////////////////////////////////////////////////////////////////////////////////////////
  // @Function:	SelectDay(Day, Month, Year, formId)
  //
  // @Description: This function updates the form field from the calling page with the formatted
  //              date that was chosen. It then closes the window (Format Month dd, yyyy)
  //             It assumes the form in the calling page is document.forms[0] and the field
  //             names are selectedDay, selectedMonth and selectedYear
  //
  // @param		Day	: The day selected
  // @param		Month: The month selected
  // @param		Year: The year selected
  // @param             formId: The index of the form in which the calendar is added
  // @return		Formatted date
  //
  ////////////////////////////////////////////////////////////////////////////
    function SelectDay(Day,Month,Year, formId)
    {
       if( formId == null && formId !='undefined'){
        formId=0;
       }
      objMonth=top.window.opener.document.forms[formId].selectedMonth;
      objDay=top.window.opener.document.forms[formId].selectedDay;
      objYear=top.window.opener.document.forms[formId].selectedYear;
      objMonth.options.selectedIndex=Month;
      objDay.options.selectedIndex=Day -1;
      for(i=0;i< objYear.options.length;i++)
      {
            if(Year==objYear.options[i].value) { objYear.options.selectedIndex=i; }
      }
          window.close();
   }
  //================================================
  //Used by Pagination.. jumps to the currently selected page
  //================================================
  function jumpTo(url, theSelect)
  {
          var index = theSelect.options[theSelect.selectedIndex].value;
          document.location.href = url + index;
  }

  //================================================
  //Used by custom device details
  //================================================
  function custom_device_details(theForm){
    if (theForm.chkAll_custDev.checked == true){
      for (i=0; i < theForm.devicePropertyOperatingSystems.length; i++) {
        theForm.devicePropertyOperatingSystems.options[i].selected=true;
      }
      for (j=0; j < theForm.devicePropertyClasses.length; j++) {
        theForm.devicePropertyClasses.options[j].selected=true;
      }
    }
    else if (theForm.chkAll_custDev.checked == false){
      for (i=0; i < theForm.devicePropertyOperatingSystems.length; i++) {
        theForm.devicePropertyOperatingSystems.options[i].selected=false;
      }
      for (j=0; j < theForm.devicePropertyClasses.length; j++) {
        theForm.devicePropertyClasses.options[j].selected=false;
      }
    }
   }
    //================================================
    //HighlightAllSelectedDevices
    //================================================
	function HighlightAllSelectedDevices(which)
	{
	        objForm=document.forms[0].elements[which];
	        if (objForm !=null && objForm.length > 0)
	        {
	                for (i=0;i<objForm.length;i++)
	                {
	                        objForm[i].selected=true;
	                }
	        }
	        else
	        {
	                return true;
	        }

	}
	
  
  //================================================
  //UpdateList
  //================================================
	function UpdateList(which, fieldName, selectedFieldName) {
	        //Initialize
	        objForm=document.forms[0];

	        foundBox=objForm.elements[fieldName];
	        FoundCounter=foundBox.length;
	        iTotalFoundDevices=FoundCounter;
	    	 
	        selectedBox=objForm.elements[selectedFieldName];
	        SelectedCounter=selectedBox.length;
	        iTotalSelectedDevices=SelectedCounter;
		    switch(which)
	        {
	        		case 1: //add all
	                        //Add devices to selected
                            for(i=0;i<iTotalFoundDevices;i++)
	                        {
	                                selectedBox[SelectedCounter]=new Option(foundBox[i].text, foundBox[i].value);
	                                SelectedCounter++;
	                        }
	                        //Remove devices from found
	                        for(i=0;i<iTotalFoundDevices;i++)
	                        {
	                                foundBox[0]=null;
	                        }
	                        hiBound=selectedBox.length-1;
							loBound=0;
							if( selectedBox.length > 0 ){
								Quicksort(selectedBox, hiBound, loBound );
							}
				    break;
					case 2: //add selected
	                        for(i=0;i<FoundCounter;i++)
	                        {
	                                if(foundBox[i].selected)
	                                {
	                                        selectedBox[SelectedCounter]=new Option(foundBox[i].text, foundBox[i].value);
	                                        foundBox[i]=null;
	                                        SelectedCounter++;
	                                        FoundCounter--;
	                                        i--;
	                                }
	                        }
							hiBound=selectedBox.length-1;
							loBound=0;
							if( selectedBox.length > 0 ){
								Quicksort(selectedBox, hiBound, loBound );
							}
				    break;
	                case 3:// remove selected
	                        for(i=0;i<SelectedCounter;i++)
	                        {
	                                if(selectedBox[i].selected)
	                                {
	                                        foundBox[FoundCounter]=new Option(selectedBox[i].text, selectedBox[i].value);
	                                        selectedBox[i]=null;
	                                        FoundCounter++;
	                                        SelectedCounter--;
	                                        i--;
	                                }
	                        }
	                        hiBound=foundBox.length-1;
							loBound=0;
							if( foundBox.length > 0 ){
								Quicksort(foundBox, hiBound, loBound );
							}
				    break;
					case 4: // remove all
	                        //Add devices to selected
	                        for(i=0;i<iTotalSelectedDevices;i++)
	                        {
	                                foundBox[FoundCounter]=new Option(selectedBox[i].text, selectedBox[i].value);
	                                FoundCounter++;
	                        }

	                        //Remove devices from found
	                        for(i=0;i<iTotalSelectedDevices;i++)
	                        {
	                                selectedBox[0]=null;
	                        }
	                        hiBound=foundBox.length-1;
							loBound=0;
							if( foundBox.length > 0 ){
								Quicksort(foundBox, hiBound, loBound );
							}
				    break;
	        }
	}
  
	///////////////////////////////////////////////////////////////////////////////////////////////
	// @Function:Quicksort(fieldName, higherBound, lowerBound )
	// @Description:This function sorts the updated selection box elements usign Quciksort algorithm. 
	////////////////////////////////////////////////////////////////////////////////////////////////
	function Quicksort(fieldName, higherBound, lowerBound )
	{
		objForm=document.forms[0];
		selectedBox=fieldName;
		var selectedArray = 0;
		var pivot, pivotpoint, lowerSwap, higherSwap, temp;
		// If two items to sort
		if (higherBound - lowerBound == 1)
		{
			if (selectedBox[lowerBound].text > selectedBox[higherBound].text)
			{
				selectedArray = selectedBox[lowerBound];
				selectedBox[lowerBound] = new Option(selectedBox[higherBound].text, selectedBox[higherBound].value);
				selectedBox[higherBound] = selectedArray;
			}
			return;
		}

		// Three or more items to sort
		pivotpoint =parseInt((lowerBound + higherBound) / 2);
		pivot = new Option(selectedBox[pivotpoint].text, selectedBox[pivotpoint].value);
		selectedBox[pivotpoint] = new Option(selectedBox[lowerBound].text, selectedBox[lowerBound].value);
		selectedBox[lowerBound] = pivot;
		lowerSwap = lowerBound + 1;
		higherSwap = higherBound;
		do {
			// Find the right lowerSwap
			while (lowerSwap <= higherSwap && selectedBox[lowerSwap].text <= pivot.text){
				lowerSwap++;
			}
			// Find the right higherSwap
			while (selectedBox[higherSwap].text > pivot.text){
				higherSwap--;
			}
			// Swap values if lowerSwap is less than higherSwap
			if (lowerSwap < higherSwap)
			{
				selectedArray = selectedBox[lowerSwap];
				selectedBox[lowerSwap] = new Option(selectedBox[higherSwap].text, selectedBox[higherSwap].value);
				selectedBox[higherSwap] = selectedArray;
			}
		} while (lowerSwap < higherSwap);

		selectedBox[lowerBound] = new Option(selectedBox[higherSwap].text, selectedBox[higherSwap].value);
		selectedBox[higherSwap] = pivot;
		// 2 or more items in first section		
		if (lowerBound < higherSwap - 1)
			Quicksort(selectedBox, higherSwap - 1, lowerBound);
		// 2 or more items in second section
		if (higherSwap + 1 < higherBound)
			Quicksort(selectedBox, higherBound, higherSwap + 1);
	}
	
	// splitter functions

	//*****************************************************************************
	// These splitter functions Copyright 2001 by Mike Hall.
	// See http://www.brainjar.com for terms of use.
	//*****************************************************************************
	function Browser() {

	  var ua, s, i;

	  this.isIE    = false;
	  this.isNS    = false;
	  this.version = null;

	  ua = navigator.userAgent;

	  s = "MSIE";
	  if ((i = ua.indexOf(s)) >= 0) {
	    this.isIE = true;
	    this.version = parseFloat(ua.substr(i + s.length));
	    return;
	  }

	  s = "Netscape6/";
	  if ((i = ua.indexOf(s)) >= 0) {
	    this.isNS = true;
	    this.version = parseFloat(ua.substr(i + s.length));
	    return;
	  }

	  // Treat any other "Gecko" top.browser as NS 6.1.

	  s = "Gecko";
	  if ((i = ua.indexOf(s)) >= 0) {
	    this.isNS = true;
	    this.version = 6.1;
	    return;
	  }
	}

	//
	// start dragging the splitter
	//
	function dragStart(event) {

	  //we can't drag if it's hidden
	  if (top.document.getElementById('TreePane').style.display == 'none') { return; }
	  top.dragObj.dragging = true;

	  id = 'TreePane';
	  var el;
	  var x, y;

	  // If an element id was given, find it. Otherwise use the element being
	  // clicked on.

	  if (id) {
	    top.dragObj.elNode = top.document.getElementById(id);
	  }

	  // Get cursor position with respect to the page.

	  if (top.browser.isIE) {
	    x = window.event.clientX + document.documentElement.scrollLeft
	      + document.body.scrollLeft;
	    y = window.event.clientY + document.documentElement.scrollTop
	      + document.body.scrollTop;
	  }
	  if (top.browser.isNS) {
	    x = event.clientX + window.scrollX;
	    y = event.clientY + window.scrollY;
	  }

	  // Save starting positions of cursor and element.

	  top.dragObj.cursorStartX = x;
	  top.dragObj.cursorStartY = y;
	  top.dragObj.elStartLeft  = parseInt(top.dragObj.elNode.style.left, 10);
	  top.dragObj.elStartTop   = parseInt(top.dragObj.elNode.style.top,  10);

	  if (isNaN(top.dragObj.elStartLeft)) top.dragObj.elStartLeft = 0;
	  if (isNaN(top.dragObj.elStartTop))  top.dragObj.elStartTop  = 0;

	  // Update element's z-index.

	  top.dragObj.elNode.style.zIndex = ++top.dragObj.zIndex;

	  // Capture mousemove and mouseup events on the page.

	  if (top.browser.isIE) {
	    document.attachEvent("onmousemove", dragGo);
	    document.attachEvent("onmouseup",   dragStop);
	    window.event.cancelBubble = true;
	    window.event.returnValue = false;
	  }
	  if (top.browser.isNS) {
	    window.addEventListener("mousemove", dragGo,   true);
	    window.addEventListener("mouseup",   dragStop, true);
	    event.preventDefault();
	  }
	}
	
	//
	// dragging the splitter
	//
	function dragGo(event) {
	  if (!top.dragObj.dragging) { return; }

	  var x, y;

	  // Get cursor position with respect to the page.

	  if (top.browser.isIE) {
	    x = window.event.clientX + document.documentElement.scrollLeft
	      + document.body.scrollLeft;
	    y = window.event.clientY + document.documentElement.scrollTop
	      + document.body.scrollTop;

	    x = event.screenX - top.window.screenLeft;
	    
	    // Move drag element by the same amount the cursor has moved.
      	var treePanelWidthTemp = x - 10;
      	var treePanelWidthTempBak = x;
      	if (treePanelWidthTemp <= 200) treePanelWidthTemp = 200;
      	if (treePanelWidthTemp >= 500) treePanelWidthTemp = 500;
      	if(treePanelWidthTemp > 200 && treePanelWidthTemp <= 480){
	  		top.dragObj.elNode.style.width =  treePanelWidthTemp + "px";
	  	}
	  	if(treePanelWidthTemp > 480 && treePanelWidthTemp < 500){
	  		top.dragObj.elNode.style.width =  treePanelWidthTempBak + "px";
	  	}
	  	
	  	//update the width of the main pane in ie
		  id = 'MainPanel';
		  mainPanel = top.document.getElementById(id);
          var mainPanelWidthTemp = top.document.body.clientWidth - x + 10;
          var mainPanelWidthTempBak = top.document.body.clientWidth - x;
          if (mainPanelWidthTemp < 500) mainPanelWidthTemp = 500;
          if(treePanelWidthTemp > 200 && treePanelWidthTemp <= 480){
	  	  	mainPanel.style.width = mainPanelWidthTemp + "px";
	  	  }	 
	  	  if(treePanelWidthTemp > 480 && treePanelWidthTemp < 500){
	  	  	mainPanel.style.width = mainPanelWidthTempBak + "px";
	  	  } 
	  	  idw = 'WizardPane';
	  	  if ( top.document.getElementById(idw) != null )
	  	  {
	  	  	wizardPanel = top.document.getElementById(idw);
	  	  	var wzdwidth = wizardPanel.offsetWidth;
	  	  	wizardPanel.style.width = wzdwidth + "px";
	  	  }
	  	  
	  	  window.event.cancelBubble = true;
	      window.event.returnValue = false;
	  }
	  if (top.browser.isNS) {
	    x = event.clientX + window.scrollX;
	    y = event.clientY + window.scrollY;
	  
	    // Move drag element by the same amount the cursor has moved.
      	var treePanelWidthTemp = x + 30; //move the pane faster
      	var treePanelWidthTempBak = x;
      	if (treePanelWidthTempBak < 200) treePanelWidthTemp = 200;
      	if (treePanelWidthTempBak >= 500) treePanelWidthTemp = 500;
      	if(treePanelWidthTemp > 200 && treePanelWidthTemp < 250){
	  		top.dragObj.elNode.style.width = treePanelWidthTempBak + "px";
	  	}
	  	if(treePanelWidthTemp >= 250 && treePanelWidthTemp < 500){
	  		top.dragObj.elNode.style.width =  treePanelWidthTemp + "px";
	  	}
	  	
	  	//update the width of the main pane in firefox
	    mainPanel = top.MainFrame;
        var mainPanelWidthTemp = top.document.body.clientWidth - x - 30;
        var mainPanelWidthTempBak = top.document.body.clientWidth - x;
        if (mainPanelWidthTemp < 500) mainPanelWidthTemp = 500;
        if(treePanelWidthTemp > 200 && treePanelWidthTemp < 250){
	  	  mainPanel.width = mainPanelWidthTempBak + "px";
	  	}
		if(treePanelWidthTemp >= 250 && treePanelWidthTemp < 500){
	  	  mainPanel.width = mainPanelWidthTemp + "px";
	  	}
	  	event.preventDefault();
	  }
	}
	
	//
	// Stop dragging the splitter
	//
	function dragStop(event) {
	  top.dragObj.dragging = false;

	  //we can't drag if it's hidden
	  var treePaneElement = top.document.getElementById('TreePane');
	  if (treePaneElement != null){
	  	if (treePaneElement.style.display == 'none') { return; }
	  }
	  

          var localElNode = top.dragObj.elNode;

	  if(localElNode != null) {
		  // Stop capturing mousemove and mouseup events.
		  if (top.dragObj.elNode.style.width != null && top.dragObj.elNode.style.width != '') {
			var width = parseInt(top.dragObj.elNode.style.width);
			//update the cookie
			setCookie('SplitterLocation', width, new Date(3000, 00, 01));
		  }
	  }

	 /* if (top.browser.isIE) {
	    document.detachEvent("onmousemove", dragGo);
	    document.detachEvent("onmouseup",   dragStop);
	  }
	  if (top.browser.isNS) {
	    document.removeEventListener("mousemove", dragGo,   true);
	    document.removeEventListener("mouseup",   dragStop, true);
	  }*/
	}
	
	//================================================
    //updateSplitter -- close or open it when you click the close/open button
    //================================================
	function updateSplitter() {
	  var cur = top.document.getElementById('TreePane').style.display;
	  if (cur == 'none') {
	      top.document.getElementById('TreePane').style.display = '';
	  } else {
	      top.document.getElementById('TreePane').style.display = 'none';
          setCookie('SplitterLocation', 0, new Date(3000, 00, 01));
	  }
	}
    
	//cookie functions
	 // * return string containing value of specified cookie or null if cookie does not exist
	 function getCookie(name) {
	   var dc = document.cookie;
	   var prefix = name + "=";
	   var begin = dc.indexOf("; " + prefix);
	   if (begin == -1) {
	     begin = dc.indexOf(prefix);
	     if (begin != 0) return null;
	   } else {
	     begin += 2;
	   }
	   var end = document.cookie.indexOf(";", begin);
	   if (end == -1)
	     end = dc.length;
	   return unescape(dc.substring(begin + prefix.length, end));
	 }

	 // name - name of the cookie
	 // value - value of the cookie
	 // [expires] - expiration date of the cookie (defaults to end of current session)
	 // [path] - path for which the cookie is valid (defaults to path of calling document)
	 // [domain] - domain for which the cookie is valid (defaults to domain of calling document)
	 // [secure] - Boolean value indicating if the cookie transmission requires a secure transmission
	 // * an argument defaults when it is assigned null as a placeholder
	 // * a null placeholder is not required for trailing omitted arguments
	 function setCookie(name, value, expires, path, domain, secure) {
	   var curCookie = name + "=" + escape(value) +
	       ((expires) ? "; expires=" + expires.toGMTString() : "") +
	       ((path) ? "; path=" + path : "") +
	       ((domain) ? "; domain=" + domain : "") +
	       ((secure) ? "; secure" : "");

	   document.cookie = curCookie;
	 }

	 // name - name of the cookie
	 // [path] - path of the cookie (must be same as path used to create cookie)
	 // [domain] - domain of the cookie (must be same as domain used to create cookie)
	 // * path and domain default if assigned null or omitted if no explicit argument proceeds
	 function deleteCookie(name, path, domain) {
	   if (getCookie(name)) {
	     var delcookie = name + "=" +
	     ((path) ? "; path=" + path : "") +
	     ((domain) ? "; domain=" + domain : "") +
	     "; expires=Thu, 01-Jan-70 00:00:01 GMT";
	     document.cookie = delcookie;
	   }
	 }

    //================================================
    //frameCheck
	//function to ensure a page is not in a frameset
    //================================================
	function frameCheck(myDocument)
	{
	  if (top.location != location) {
	    top.location.href = myDocument.location.href ;
	  }
	}
      //Allows to select the url from a dropdown and submit to that URL
      function dropDownItemRedirectPage(form){
        myChoice = form.reportDropDownSelected.selectedIndex;
        /* This line of code assigns the highlighted item in the list menu to a variable.
        Make sure you refer to the right form name and to the right List/Menu name. */
        mySelection=form.reportDropDownSelected.options[myChoice].value;
        /* This line of code assigns the dynamically choosen option to a variable. */
        form.action=mySelection;
        form.submit();
        /* This line of code replaces the current page with the selected item. */
      }
      function closeCalendarPopup()
      {
        if (typeof(top.calendarWindow) == "object") {
          top.calendarWindow.close();
        }

      }
      //================================================
    //checkValue -- check the value of Data Window drop down boxes
    //and disable the Data Window Minute basesd on the selection of Data
    //Window Hours. If the hour selection is 72, it disables the drop down for
    //minute and resets the minute drop down box.
    //================================================

      function checkValue()
      {
       listHour=document.forms[0].dataWindowHours;
       listMinute=document.forms[0].dataWindowMinutes;
        if (listHour !=null && listHour.length > 0)
        {
             if(listHour.value == "72"){
              listMinute.value="0";
              listMinute.disabled=true;
             }
             else{
                listMinute.disabled=false;
             }
         }

      }
      
    //============================================================
    //setElementStyleClass -- set the style class for an element.
    //Initially used to toggle between greyed out text to normal
    //when enabled/disabling page options with a radio button
    //
    // [elementID] the id of the DOM element to modify
    // [styleClass] the style class to set the element to
    //============================================================
    function setElementStyleClass(elementID, styleClass) {
	    if(document.getElementById(elementID) != null) {
	      document.getElementById(elementID).setAttribute("class", styleClass);
	      document.getElementById(elementID).setAttribute("className", styleClass); //for IE
	    }
	  }
	  
	  //============================================================
    //disabledCollection -- enabled or disabled controls in a collection
    //Initially used to enabled and disabled controls based on a 
    //radio button selection
    //
    // [collection] the DOM collection to modify
    // [value] the value to set in the disabled field for each
    //         member of the collection (true or false)
    //============================================================
    function disableCollection(collection, value) {
	  for (i=0;i<collection.length;i++)
  	  {
    	collection[i].disabled = value;
	  }
  	}
  	 	
  	//============================================================
    //initDisabledWindowsAsset -- used to initialize the disabled
    //text fields and controls on a windows asset page.
    //This should be called from the <body onload()> event of a
    //jsp.
    //Currently this will be called from the following jsps:
    // add_windows_asset_task.jsp
    // edit_windows_asset_task.jsp
    //
    // [scan] the inital value of the radio button representing
    //        the selected scan option (should be one of 'scanNow'
    //        or 'recurring'). This value is pulled from the
    //        AutoDiscoverForm.scheduleSelection property
    //============================================================
  	function initDisabledWindowsAsset(scan) {
    	windowsAssetScheduleChange(scan);
	  }
	  
	  //============================================================
    //windowsAssetScheduleChange -- used to toggle the correct
    //fields between disabled and enabled when the user selects
    //different schedule options.
    //This should be called from the <radio onclick()> event of a
    //jsp.
    //Currently this will be called from the following jsps:
    // add_windows_asset_task.jsp
    // edit_windows_asset_task.jsp
    //
    // [scan] the value of the radio button representing
    //        the clicked scan option (should be one of 'scanNow'
    //        or 'recurring')
    //============================================================
		function windowsAssetScheduleChange(scan)
	  {
	    var boolScanNow = false;
	    if(scan == 'scanNow') {
	      boolScanNow = true;
	    }
	    disableCollection(document.getElementsByName("startHour"), boolScanNow);
	    disableCollection(document.getElementsByName("startMinute"), boolScanNow);
	    disableCollection(document.getElementsByName("dayOfTheWeek"), boolScanNow);
	    disableCollection(document.getElementsByName("monthlyOnDays"), boolScanNow);
	
	    if(boolScanNow) {
	      setElementStyleClass("startTime", "disabledField");
	      setElementStyleClass("daysOfTheWeek", "disabledField");
	      setElementStyleClass("monthlyOnDays", "disabledField");
	      setElementStyleClass("startTimeValue", "disabledField");
	      setElementStyleClass("daysOfTheWeekValue", "disabledField");
	      setElementStyleClass("monthlyOnDaysValue", "disabledField");
	    }
	    else {
	      setElementStyleClass("startTime", "label");
	      setElementStyleClass("daysOfTheWeek", "label");
	      setElementStyleClass("monthlyOnDays", "label");
	      setElementStyleClass("startTimeValue", "label");
	      setElementStyleClass("daysOfTheWeekValue", "label");
	      setElementStyleClass("monthlyOnDaysValue", "label");
	    }
	  }
	  
	  	 	
  	//============================================================
    //initTargetNetwork -- used to initialize the disabled
    //text fields (Target Network) on add/edit discovery pages
    //============================================================
	  function initTargetNetwork(ipRangeType) {
	  	targetNetworkChange(ipRangeType)
	  }
	  
	//============================================================	  
	//targetNetworkChange -- used to toggle the correct
    //fields between disabled and enabled when the user selects
    // different Target Network selection on add/edit discovery page
    //============================================================
	  function targetNetworkChange(ipRangeType){
	    if(ipRangeType == 'false') {
			disableCollection(document.getElementsByName("ipRange"), true);
			disableCollection(document.getElementsByName("ipAddress"), false);
	    	disableCollection(document.getElementsByName("selectedNetmask"), false);
	    	setElementStyleClass("ipRangeExample", "disabledField");
	    	setElementStyleClass("netmask", "label");
	    }
	    else{
	    	disableCollection(document.getElementsByName("ipRange"), false);
	    	disableCollection(document.getElementsByName("ipAddress"), true);
	    	disableCollection(document.getElementsByName("selectedNetmask"), true);
	    	setElementStyleClass("ipRangeExample", "label");
	    	setElementStyleClass("netmask", "disabledField");
	    }
	  }
	  
	  //============================================================
    //initDisabledDeviceDowntime -- used to initialize the disabled
    //text fields and controls for device downtime on the device 
    //details page.
    //This should be called from the <body onload()> event of a
    //jsp.
    //Currently this will be called from the following jsps:
    // add_device.jsp
    // edit_device.jsp
    //
    // [downTime] the inital value of the radio button representing
    //            the selected scan option (should be one of 'off'
    //            or 'once' or 'repeat'). This value is pulled from the
    //            DeviceForm.downTimeStatus property
    //============================================================
	  function initDisabledDeviceDowntime(downTime) {
	    deviceDowntimeChange(downTime);
	  }
	  
	  //============================================================
    //deviceDowntimeChange -- used to toggle the correct
    //fields between disabled and enabled when the user selects
    //different schedule options.
    //This should be called from the <radio onclick()> event of a
    //jsp.
    //Currently this will be called from the following jsps:
		// add_device.jsp
    // edit_device.jsp
    //
    // [downTime] the value of the radio button representing
    //        the clicked scan option (should be one of 'off'
    //        or 'once' or 'repeat')
    //============================================================
	function deviceDowntimeChange(downTime)
  	{
	    var boolOnceDisabled = true;
	    var boolRepeatDisabled = true;
	    var boolNowDisabled = true;

	    if(downTime == 'once') {
	      boolOnceDisabled = false;
	    }
	    if(downTime == 'repeat') {
	      boolRepeatDisabled = false;
	    }
	    if(downTime == 'now') {
	      boolNowDisabled = false;
	    }
	    
	    disableCollection(document.getElementsByName("onceStartTime"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceStartYear"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceStartMonth"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceStartDay"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceStartHour"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceStartMinute"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndTime"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndYear"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndMonth"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndDay"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndHour"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("onceEndMinute"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("recurringStartHour"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("recurringStartMinute"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("recurringEndHour"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("recurringEndMinute"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("dayOfWeek"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("monthlySchedule"), boolRepeatDisabled);
	    disableCollection(document.getElementsByName("nowStartTime"), boolOnceDisabled);
	    disableCollection(document.getElementsByName("nowEndTime"), boolOnceDisabled);
	 	    
	    if(boolOnceDisabled) {
	      setElementStyleClass("onceStartTime", "disabledField");
	      setElementStyleClass("onceStartTimeValue", "disabledField");
	      setElementStyleClass("onceEndTime", "disabledField");
	      setElementStyleClass("onceEndTimeValue", "disabledField");
	    }
	    else {
	      setElementStyleClass("onceStartTime", "label");
	      setElementStyleClass("onceStartTimeValue", "label");
	      setElementStyleClass("onceEndTime", "label");
	      setElementStyleClass("onceEndTimeValue", "label");
	    }
	    
	    if(boolRepeatDisabled) {     
	      setElementStyleClass("recurringStartTime", "disabledField");
	      setElementStyleClass("recurringStartTimeValue", "disabledField");
	      setElementStyleClass("recurringEndTime", "disabledField");
	      setElementStyleClass("recurringEndTimeValue", "disabledField");
	      setElementStyleClass("dayOfWeek", "disabledField");
	      setElementStyleClass("dayOfWeekValue", "disabledField");
	      setElementStyleClass("monthlySchedule", "disabledField");
	      setElementStyleClass("monthlyScheduleValue", "disabledField");
	    }
	    else {
	      setElementStyleClass("recurringStartTime", "label");
	      setElementStyleClass("recurringStartTimeValue", "label");
	      setElementStyleClass("recurringEndTime", "label");
	      setElementStyleClass("recurringEndTimeValue", "label");
	      setElementStyleClass("dayOfWeek", "label");
	      setElementStyleClass("dayOfWeekValue", "label");
	      setElementStyleClass("monthlySchedule", "label");
	      setElementStyleClass("monthlyScheduleValue", "label");
	    }
	    
	    if (boolNowDisabled){
	      setElementStyleClass("nowStartTime", "disabledField");
	      setElementStyleClass("nowStartTimeValue", "disabledField");
	      setElementStyleClass("nowEndTime", "disabledField");
	      setElementStyleClass("nowEndTimeValue", "disabledField");
	    }
	    else{
	      setElementStyleClass("nowStartTime", "label");
	      setElementStyleClass("nowStartTimeValue", "label");
	      setElementStyleClass("nowEndTime", "label");
	      setElementStyleClass("nowEndTimeValue", "label");
	    }
  	}
  	
	
  	//============================================================
    //Used to disable the smart folder properties when the option flag is false and vice-versa
    //============================================================
  	function smartFolderOptionChange(option)
  	{
	    var boolSmartFolderDisabled = true;
	    if(option.checked) {
	      boolSmartFolderDisabled = false;
	    }
	    
	    if(boolSmartFolderDisabled) {
	    	UpdateList(4, 'selectedDeviceClassList', 'selectedDeviceClassIdAr');
	    	UpdateList(4, 'selectedOSList', 'selectedOSIdAr');	    		 
	    }
	    
	    disableCollection(document.getElementsByName("patternName"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("selectedOSList"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("selectedOSIdAr"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("selectedDeviceClassList"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("selectedDeviceClassIdAr"), boolSmartFolderDisabled);
	    
	    disableCollection(document.getElementsByName("allMatch"), boolSmartFolderDisabled);	    
	    disableCollection(document.getElementsByName("ignoreCase"), boolSmartFolderDisabled);
	    
	    disableCollection(document.getElementsByName("addAllSmartFolder"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("addSelectedSmartFolder"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("removeSelectedSmartFolder"), boolSmartFolderDisabled);
	    disableCollection(document.getElementsByName("removeAllSmartFolder"), boolSmartFolderDisabled);
	    
	    if(boolSmartFolderDisabled) {	    
 	      setElementStyleClass("anyOrAll", "DisabledField");
 	      setElementStyleClass("match", "DisabledField");
 	      setElementStyleClass("availableDeviceClasses", "DisabledField");
 	      setElementStyleClass("selectedDeviceClasses", "DisabledField");
 	      setElementStyleClass("availableOS", "DisabledField");
 	      setElementStyleClass("selectedOS", "DisabledField");
 	      setElementStyleClass("patternName", "DisabledField");
 	      setElementStyleClass("ignoreCase", "DisabledField");
 	      
	      setElementStyleClass("addAllDeviceClassButton", "DisabledButton");
	      setElementStyleClass("addSelectedDeviceClassButton", "DisabledButton");
	      setElementStyleClass("removeSelectedDeviceClassButton", "DisabledButton");
	      setElementStyleClass("removeAllDeviceClassButton", "DisabledButton");
	      setElementStyleClass("addAllOSButton", "DisabledButton");
	      setElementStyleClass("addSelectedOSButton", "DisabledButton");
	      setElementStyleClass("removeSelectedOSButton", "DisabledButton");
	      setElementStyleClass("removeAllOSButton", "DisabledButton");
	          
	    }
	   	else {
	   	 	setElementStyleClass("anyOrAll", "label");
	   	 	setElementStyleClass("match", "label");
	   	 	setElementStyleClass("availableDeviceClasses", "label");
 	      setElementStyleClass("selectedDeviceClasses", "label");
 	      setElementStyleClass("availableOS", "label");
 	      setElementStyleClass("selectedOS", "label");
 	      setElementStyleClass("patternName", "label");
 	      setElementStyleClass("ignoreCase", "label");
	   	
	    	setElementStyleClass("addAllDeviceClassButton", "Button");
	      setElementStyleClass("addSelectedDeviceClassButton", "Button");
	      setElementStyleClass("removeSelectedDeviceClassButton", "Button");
	      setElementStyleClass("removeAllDeviceClassButton", "Button");
	      setElementStyleClass("addAllOSButton", "Button");
	      setElementStyleClass("addSelectedOSButton", "Button");
	      setElementStyleClass("removeSelectedOSButton", "Button");
	      setElementStyleClass("removeAllOSButton", "Button");
	    }	    
  	}
  	
  	//============================================================
    //initDisabledManagementTask -- used to initialize the disabled
    // text fields and controls for a selected packages and schedule
    // on the management task page.
    //This should be called from the <body onload()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // add_management_task.jsp
    // edit_management_task.jsp
    //
    // [packageLocation] the inital value of the radio button representing
    //            the selected package location (should be one of 'uploaded'
    //            or 'existing'). This value is pulled from the
    //            RemoteExecutionForm.packageType property
    // [schedule] the inital value of the radio button representing
    //            the selected schedule type (should be one of 'OnceNow'
    //            or 'OnceLater' or 'Recurring'). This value is pulled from the
    //            RemoteExecutionForm.scheduleType property
    //============================================================
    function initDisabledManagementTask(packageLocation, schedule) {
    	managementTaskPackageChange(packageLocation);
	    managementTaskScheduleChange(schedule);
  	}
  	
  	//============================================================
    //managementTaskPackageChange -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // different package location options.
    //This should be called from the <radio onclick()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // add_management_task.jsp
    // edit_management_task.jsp
    //
    // [type] the value of the radio button representing
    //        the clicked package type (should be one of 'uploaded'
    //        or 'existing')
    //============================================================
  	function managementTaskPackageChange(type)
	  {
	    var boolLocalSystemDisabled = false;
	    var boolRepositoryDisabled = false;
	    if(type == 'uploaded') {
	      boolRepositoryDisabled = true;
	    }
	    else if(type == 'existing') {
	      boolLocalSystemDisabled = true;
	    }
	
	    disableCollection(document.getElementsByName("selectedExecItem"), boolRepositoryDisabled);
	    disableCollection(document.getElementsByName("uploadedFileName"), boolLocalSystemDisabled);
	    disableCollection(document.getElementsByName("uploadedFileDescription"), boolLocalSystemDisabled);
	    disableCollection(document.getElementsByName("scriptingPackageFile"), boolLocalSystemDisabled);
	    disableCollection(document.getElementsByName("distributionPackageFile"), boolLocalSystemDisabled);
	    disableCollection(document.getElementsByName("distributionParametersFile"), boolLocalSystemDisabled);
	
	    if(boolRepositoryDisabled) {
	      setElementStyleClass("softwareDistribution", "disabledField");
	      setElementStyleClass("script", "disabledField");
	      setElementStyleClass("description", "disabledField");
	    }
	    else {
	      setElementStyleClass("softwareDistribution", "label");
	      setElementStyleClass("script", "label");
	      setElementStyleClass("description", "label");
	    }
	
	    if(boolLocalSystemDisabled) {
	      setElementStyleClass("uploadedFileName", "disabledField");
	      setElementStyleClass("uploadedFileDescription", "disabledField");
	      setElementStyleClass("distributionPackageFile", "disabledField");
	      setElementStyleClass("distributionParametersFile", "disabledField");
	      setElementStyleClass("scriptFile", "disabledField");
	    }
	    else {
	      setElementStyleClass("uploadedFileName", "label");
	      setElementStyleClass("uploadedFileDescription", "label");
	      setElementStyleClass("distributionPackageFile", "label");
	      setElementStyleClass("distributionParametersFile", "label");
	      setElementStyleClass("scriptFile", "label");
	    }
	  }
	  
	  //================================================================
	  //agentManagementTask -- disable fields when the distribution
	  //task management is executed by a local agent
	  //================================================================
	  function agentManagementTask(readOnly)
	  {
	    var boolAgentManagement = false;
	    
	    if(readOnly == 'true') {
	      boolAgentManagement = true;
	    }
	    
	    disableCollection(document.getElementsByName("useLocalAgent"), boolAgentManagement);
	    disableCollection(document.getElementsByName("selectedProbe"), boolAgentManagement);
	    disableCollection(document.getElementsByName("devicesFound"), boolAgentManagement);
	    disableCollection(document.getElementsByName("selectedDevices"), boolAgentManagement);
	   	    
	    if(boolAgentManagement){
	      setElementStyleClass("useLocalAgent", "disabledField");
	      setElementStyleClass("selectedProbe", "disabledField");
	      setElementStyleClass("devicesFound", "disabledField");
	      setElementStyleClass("selectedDevices", "disabledField");
	      setElementStyleClass("addSelectedButton", "disabledButton");
  		  document.getElementById("addSelectedButton").disabled=true;
  		  setElementStyleClass("removeSelectedButton", "disabledButton");
  		  document.getElementById("removeSelectedButton").disabled=true;
  		  setElementStyleClass("removeAllButton", "disabledButton");
  		  document.getElementById("removeAllButton").disabled=true;
  		  setElementStyleClass("addAllButton", "disabledButton");
  		  document.getElementById("addAllButton").disabled=true;
	    }

	  }
	  
	  //============================================================
    //managementTaskScheduleChange -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // different schedule options.
    //This should be called from the <radio onclick()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // add_management_task.jsp
    // edit_management_task.jsp
    //
    // [type] the value of the radio button representing
    //        the clicked schedule type (should be one of 'OnceNow'
    //        or 'OnceLater' or 'Recurring')
    //============================================================
	  function managementTaskScheduleChange(type)
	  {
	    var boolScheduledDisabled = false;
	    var boolRecurringDisabled = false;
	    if(type == 'OnceNow') {
	      boolRecurringDisabled = true;
	      boolScheduledDisabled = true;
	    }
	    else if(type == 'Recurring') {
	      boolScheduledDisabled = true;
	    }
	    else if(type == 'OnceLater') {
	      boolRecurringDisabled = true;
	    }
	
	    disableCollection(document.getElementsByName("selectedMonth"), boolScheduledDisabled);
	    disableCollection(document.getElementsByName("selectedDay"), boolScheduledDisabled);
	    disableCollection(document.getElementsByName("selectedYear"), boolScheduledDisabled);
	    disableCollection(document.getElementsByName("hour"), boolScheduledDisabled);
	    disableCollection(document.getElementsByName("minute"), boolScheduledDisabled);
	
	    disableCollection(document.getElementsByName("recurranceDayOfMonth"), boolRecurringDisabled);
	    disableCollection(document.getElementsByName("recurranceHour"), boolRecurringDisabled);
	    disableCollection(document.getElementsByName("recurranceMinute"), boolRecurringDisabled);
	    disableCollection(document.getElementsByName("recurranceWeeklyOn"), boolRecurringDisabled);
	
	    if(boolScheduledDisabled) {
	      setElementStyleClass("startDateAndTime", "disabledField");
	    }
	    else {
	      setElementStyleClass("startDateAndTime", "label");
	    }
	
	    if(boolRecurringDisabled) {
	      setElementStyleClass("daily", "disabledField");
	      setElementStyleClass("weekly", "disabledField");
	      setElementStyleClass("weeklyValue", "disabledField");
	      setElementStyleClass("monthly", "disabledField");
	      setElementStyleClass("monthlyOnDays", "disabledField");
	      setElementStyleClass("monthlyOnDaysValue", "disabledField");
	      setElementStyleClass("recurringSchedule", "disabledField");
	      setElementStyleClass("recurringTime", "disabledField");
	    }
	    else {
	      setElementStyleClass("daily", "label");
	      setElementStyleClass("weekly", "label");
	      setElementStyleClass("monthly", "label");
		   setElementStyleClass("weeklyValue", "label");
	      setElementStyleClass("monthlyOnDays", "label");
	      setElementStyleClass("monthlyOnDaysValue", "label");
	      setElementStyleClass("recurringSchedule", "label");
	      setElementStyleClass("recurringTime", "label");
	    }
	
	  }
	  
	  //============================================================
    //userProfileScheduleChange -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // different schedule options.
    //This should be called from the <radio onclick()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // edit_user_notification.jsp
    // add_user_notification.jsp
    // add_account_notification.jsp
    // edit_account_notification.jsp
    //
    // [scan] the value of the radio button representing
    //        the clicked schedule type (should be one of 'entireDay'
    //        or 'dailyInterval')
    // [element] the selected element name (since there can be multiple
    //           schedules on the same page, we need to know which
    //           one the user is toggling)
    //============================================================
		function userProfileScheduleChange(scan, element)
	  {  
	   var arr = element.split(".");
	   element = arr[0];
	    	
	    var boolEntireDay = false;
	    if(scan == 'entireDay') {
	      boolEntireDay = true;
	    }
	
	    disableCollection(document.getElementsByName(element + ".scheduleStartHour"), boolEntireDay);
	    disableCollection(document.getElementsByName(element + ".scheduleStartMinute"), boolEntireDay);
	    disableCollection(document.getElementsByName(element + ".scheduleEndHour"), boolEntireDay);
	    disableCollection(document.getElementsByName(element + ".scheduleEndMinute"), boolEntireDay);
	
	    if(boolEntireDay) {
	      setElementStyleClass(element + ".startTime", "disabledField");
	      setElementStyleClass(element + ".endTime", "disabledField");
	    }
	    else {
	      setElementStyleClass(element + ".startTime", "label");
	      setElementStyleClass(element + ".endTime", "label");
	    }
	  }
	  
	  //============================================================
    //initDisabledCronBasedService -- used to initialize the disabled
    // text fields and controls for a selected pacakges and schedule
    // on the management task page.
    //This should be called from the <body onload()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // edit_service.jsp
    //
    // [onceDailySchedule] the inital value of the radio button representing
    //            the whether this is a once daily schedule or not (should be 
    //            one of 'true' or 'false'). This value is pulled from the
    //            ServiceForm.cronOnceDaily property

    //============================================================
	 	function initDisabledCronBasedService(onceDailySchedule) {
    	cronBasedServiceScheduleChange(onceDailySchedule);
   	}
   	
   	//============================================================
    //cronBasedServiceScheduleChange -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // different schedule options.
    //This should be called from the <radio onclick()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // edit_service.jsp
    //
    // [onceDaily] the value of the radio button representing
    //        the clicked schedule type (should be one of 'true'
    //        or 'false')
    //============================================================
   	function cronBasedServiceScheduleChange(onceDaily)
	  {
	    var boolOnceDaily = false;
	    if(onceDaily == 'true') {
	      boolOnceDaily = true;
	    }
	
	    disableCollection(document.getElementsByName("onceDailyHour"), !boolOnceDaily);
	    disableCollection(document.getElementsByName("onceDailyMinute"), !boolOnceDaily);
	
	    disableCollection(document.getElementsByName("startHour"), boolOnceDaily);
	    disableCollection(document.getElementsByName("endHour"), boolOnceDaily);
	    disableCollection(document.getElementsByName("minute"), boolOnceDaily);
	
	    if(boolOnceDaily) {
	      setElementStyleClass("scanIntervalMinute", "disabledField");
	      setElementStyleClass("startHour", "disabledField");
	      setElementStyleClass("endHour", "disabledField");
	      setElementStyleClass("onceDailyTime", "label");
	    }
	    else {
	      setElementStyleClass("scanIntervalMinute", "label");
	      setElementStyleClass("startHour", "label");
	      setElementStyleClass("endHour", "label");
	      setElementStyleClass("onceDailyTime", "disabledField");
	    }
	  }
	  
	  //=========================================================
	  //Hide the error text when the user clicks on the
    //export button. This approach will avoid all those potential page refreshes,
    //but still achieve the same result from a user perspective
    //=========================================================
  function clearErrorMessage()
    {
    	if( document.getElementById('errors') != null ){
	      document.getElementById('errors').innerHTML="";
        }
    }
	  
   	//============================================================
    //generateNotificationScheduleGraph -- used to generate a graph
    // of the notification schedule by dynamically sizing the contents
    // of a table.
    //This should be called from all click or change events of a
    // notification profile schedule.
    //Currently this will be called from the following jsps:
    // edit_user_notificaiton.jsp
    // add_user_notification.jsp
    // edit_account_notification.jsp
    // add_account_notificaition.jsp
    //
    // [control] the .name of the control which triggerd this function
    //           call. (i.e. notificationMethod[x].something). We extract
    //           the base name (notificationMethod[x]) and modifiy that 
    //           particular schedule table.
    //============================================================
	  function generateNotificationScheduleGraph(control) {
			var min_in_day = 1440;
			var arr = control.split(".");
			var element = arr[0];
			
			var scheduleSelection = ""
			if(document.getElementsByName(element + ".scheduleSelection")[0].checked) {
				scheduleSelection = document.getElementsByName(element + ".scheduleSelection")[0].value;
			}
			else {
				scheduleSelection = document.getElementsByName(element + ".scheduleSelection")[1].value;
			}
		  var sun = document.getElementsByName(element + ".sun")[0].checked;
		 	var mon = document.getElementsByName(element + ".mon")[0].checked;
		  var tue = document.getElementsByName(element + ".tue")[0].checked;
		  var wed = document.getElementsByName(element + ".wed")[0].checked;
		  var thu = document.getElementsByName(element + ".thu")[0].checked;
		  var fri = document.getElementsByName(element + ".fri")[0].checked;
		  var sat = document.getElementsByName(element + ".sat")[0].checked;
	    var scheduleStartHour = Number(document.getElementsByName(element + ".scheduleStartHour")[0].value);
		  var scheduleStartMinute = Number(document.getElementsByName(element + ".scheduleStartMinute")[0].value);
	    var scheduleEndHour = Number(document.getElementsByName(element + ".scheduleEndHour")[0].value);
		  var scheduleEndMinute = Number(document.getElementsByName(element + ".scheduleEndMinute")[0].value);
		  var sunTr = document.getElementById(element + '.sunTR');
 		  var monTr = document.getElementById(element + '.monTR');
 		  var tueTr = document.getElementById(element + '.tueTR');
 		  var wedTr = document.getElementById(element + '.wedTR');
 		  var thuTr = document.getElementById(element + '.thuTR');
 		  var friTr = document.getElementById(element + '.friTR');
 		  var satTr = document.getElementById(element + '.satTR');    
		  
		  if(scheduleSelection == "entireDay") {
		  	if(sun == true) {
		  		setNotificationScheduleCellStyle(sunTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(sunTr, 100, 0, 0, 0);
		  	}

		  	if(mon == true) {
		  		setNotificationScheduleCellStyle(monTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(monTr, 100, 0, 0, 0);
		  	}
		  	if(tue == true) {
		  		setNotificationScheduleCellStyle(tueTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(tueTr, 100, 0, 0, 0);
		  	}
		  	if(wed == true) {
		  		setNotificationScheduleCellStyle(wedTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(wedTr, 100, 0, 0, 0);
		  	}
		  	if(thu == true) {
		  		setNotificationScheduleCellStyle(thuTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(thuTr, 100, 0, 0, 0);
		  	}
		  	if(fri == true) {
		  		setNotificationScheduleCellStyle(friTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(friTr, 100, 0, 0, 0);
		  	}
		  	if(sat == true) {
		  		setNotificationScheduleCellStyle(satTr, 0, 100, 0, 0);
		  	}
		  	else {
			  	setNotificationScheduleCellStyle(satTr, 100, 0, 0, 0);
		  	}
		  }
		  else {
		  	var curDay1 = Number(-1);
		  	var curDay2 = Number(-1);
		  	var nextDay1 = Number(-1);
		  	var nextDay2 = Number(-1);
		  	
		  	curDay1 = (scheduleStartHour * 60 + scheduleStartMinute) / min_in_day * 100; 
		  
			  if(scheduleStartHour > scheduleEndHour || (scheduleStartHour == scheduleEndHour && scheduleStartMinute >= scheduleEndMinute)) {
			  	//time will spill into next day
	        curDay2 = 100;
	        		
	        nextDay1 = 0;
	        nextDay2 = (scheduleEndHour * 60 + scheduleEndMinute) / min_in_day * 100;
	      }
	      else {
	        //time is contained with one day
	        curDay2 = (scheduleEndHour * 60 + scheduleEndMinute) / min_in_day * 100;
	      }
	       
	      if(sun == true) {
	      	if(nextDay2 != -1 && sat == true) {
 			  		setNotificationScheduleCellStyle(sunTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
				  	setNotificationScheduleCellStyle(sunTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);			  
			  	}
		  	}
		  	else {
		  		if(nextDay2 != -1 && sat == true) {
				  	setNotificationScheduleCellStyle(sunTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
				  	setNotificationScheduleCellStyle(sunTr, 100, 0, 0, 0);
				  }
		  	}

	      if(mon == true) {
	      	if(nextDay2 != -1 && sun == true) {
			  		setNotificationScheduleCellStyle(monTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(monTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
			  	if(nextDay2 != -1 && sun == true) {
			  		setNotificationScheduleCellStyle(monTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(monTr, 100, 0, 0, 0);
			  	}
		  	}
		  	
		  	if(tue == true) {
	      	if(nextDay2 != -1 && mon == true) {
			  		setNotificationScheduleCellStyle(tueTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(tueTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
		  		if(nextDay2 != -1 && mon == true) {
			  		setNotificationScheduleCellStyle(tueTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(tueTr, 100, 0, 0, 0);
			  	}
		  	}

	      if(wed == true) {
	      	if(nextDay2 != -1 && tue == true) {
			  		setNotificationScheduleCellStyle(wedTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(wedTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
			  	if(nextDay2 != -1 && tue == true) {
			  		setNotificationScheduleCellStyle(wedTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
				  	setNotificationScheduleCellStyle(wedTr, 100, 0, 0, 0);
				  }
		  	}
		  	
		  	if(thu == true) {
	      	if(nextDay2 != -1 && wed == true) {
			  		setNotificationScheduleCellStyle(thuTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(thuTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
			  	if(nextDay2 != -1 && wed == true) {
			  		setNotificationScheduleCellStyle(thuTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
				  	setNotificationScheduleCellStyle(thuTr, 100, 0, 0, 0);
			  	}
		  	}

	      if(fri == true) {
	      	if(nextDay2 != -1 && thu == true) {
			  		setNotificationScheduleCellStyle(friTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(friTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
			  	if(nextDay2 != -1 && thu == true) {
			  		 setNotificationScheduleCellStyle(friTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
				  	setNotificationScheduleCellStyle(friTr, 100, 0, 0, 0);
				  }
		  	}
		  	
		  	if(sat == true) {
	      	if(nextDay2 != -1 && fri == true) {
			  		setNotificationScheduleCellStyle(satTr, 0, Math.round(nextDay2), Math.round(curDay1 - nextDay2), Math.round(100 - curDay1));
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(satTr, Math.round(curDay1), Math.round(curDay2 - curDay1), Math.round(100 - curDay2), 0);
			  	}
		  	}
		  	else {
		  		if(nextDay2 != -1 && fri == true) {
			  		setNotificationScheduleCellStyle(satTr, 0, Math.round(nextDay2), Math.round(100 - nextDay2), 0);
			  	}
			  	else {
			  		setNotificationScheduleCellStyle(satTr, 100, 0, 0, 0);
			  	}
		  	}

		  }
		 
	}
	
	 //============================================================
    //setNotificationScheduleCellStyle -- used to size the <TD> tags
    // width a <tr> row, with the intention for the size of the tds
    // to represent a bar type graph.
    //This should be called from the generateNotificationScheduleGraph
    //method
    //
    // [row] the DOM row in which the 4 <td>'s are contained
    // [val1] the width (in %) to set the first <td>. This will be
    //        coloured the 'inactive' color
    // [val2] the width (in %) to set the second <td>. This will be
    //        coloured the 'active' color
    // [val3] the width (in %) to set the third <td>. This will be
    //        coloured the 'inactive' color
    // [val4] the width (in %) to set the forth <td>. This will be
    //        coloured the 'active' color
    //============================================================
 	function setNotificationScheduleCellStyle(row, val1, val2, val3, val4) {
		var activeColour="rgb(212,212,212)";
		var inactiveColour="#ffffff";
		row.cells[0].style.backgroundColor = inactiveColour;
		row.cells[0].style.width = val1;
		row.cells[1].style.backgroundColor = activeColour;
		row.cells[1].style.width = val2;
		row.cells[2].style.backgroundColor = inactiveColour;
		row.cells[2].style.width = val3;
		row.cells[3].style.backgroundColor = activeColour;
		row.cells[3].style.width = val4;
	}
	  
  	//============================================================
    //notificationScheduleRadioClick -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // different schedule options, and also regenerate the the
    // schedule graph.
    //
    //This should be called from the <radio onclick()> event of a
    // jsp.
    //Currently this will be called from the following jsps:
    // edit_user_notificaiton.jsp
    // add_user_notification.jsp
    // edit_account_notification.jsp
    // add_account_notificaition.jsp
    //
    // [value] the value of the radio button representing
    //         the clicked package type (should be one of 'onceDaily'
    //         or 'recurring')
    // [control] the name of the control that was clicked (used to
    //           differentiate between the different possible schedules)
    //============================================================
  function notificationScheduleRadioClick(value, control) {
 	  generateNotificationScheduleGraph(control);
	  userProfileScheduleChange(value, control);
  }

  //Called from body tag of edit_device_system_communication.jsp  
  //assetScanRequired is the flag which is determined on the basis of Device OS
  //performAssetScan is the flag which on the JSP to be toggled by user
  function initAssetScan(assetScanRequired, performAssetScan) {
  	passInfo="false";
  	if(performAssetScan=='true'){
  	 passInfo="true";
  	}
  	if(assetScanRequired=='true'){
    	enableDisableAssetScan(passInfo);//call the method to enable or disable the asset scan tab
    }
  }  
  function assetScanChange(){  	
  	passInfo="false"; 	
  	var assetScan1=document.forms[0].performAssetScan.checked;
  	if(assetScan1==true){
  	 passInfo="true";
  	}
  	enableDisableAssetScan(passInfo);
  }
  function assetScanDisable() {
    enableDisableAssetScan("false");
  }
  function enableDisableAssetScan(performAssetScan1){
  		if(performAssetScan1=='true') {
	      setElementStyleClass("performAssetScanDisplay", "label");
	      //document.getElementById("assetScanLogName").disabled=false;
	      disableCollection(document.getElementsByName("assetScanLogName"), !performAssetScan1);
	      disableCollection(document.getElementsByName("assetScanLogLevel"), !performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanStartMinute"), !performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanStartHour"), !performAssetScan1);
	      //document.getElementById("assetScanMonthlySchedule").disabled=false;
	      disableCollection(document.getElementsByName("assetScanMonthlySchedule"), !performAssetScan1);
	      disableCollection(document.getElementsByName("assetScanDayOfWeek"), !performAssetScan1);  
	    }
	    else{	    
  	      setElementStyleClass("performAssetScanDisplay", "DisabledField");
  	      disableCollection(document.getElementsByName("assetScanLogName"), performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanLogLevel"), performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanStartMinute"), performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanStartHour"), performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanMonthlySchedule"), performAssetScan1);
  	      disableCollection(document.getElementsByName("assetScanDayOfWeek"), performAssetScan1);
	    }
  }
  
  function enableDisableAdvancedDiscovery(snmpEnabled)
  {
	    var boolSnmpDisabled = true;
	    if(snmpEnabled == 'true' || snmpEnabled == true) {
	      boolSnmpDisabled = false;
	    }

	    disableCollection(document.getElementsByName("snmpCommunityString"), boolSnmpDisabled);
	    disableCollection(document.getElementsByName("snmpNumberOfRetries"), boolSnmpDisabled);
	    disableCollection(document.getElementsByName("snmpTimeout"), boolSnmpDisabled);
	    disableCollection(document.getElementsByName("snmpVersion"), boolSnmpDisabled);
	   	    
	    if(boolSnmpDisabled) {
	      setElementStyleClass("snmpCommunityString", "disabledField");
	      setElementStyleClass("snmpNumberOfRetries", "disabledField");
	      setElementStyleClass("snmpTimeout", "disabledField");
	      setElementStyleClass("snmpVersion", "disabledField");
	    }
	    else {
	      setElementStyleClass("snmpCommunityString", "label");
	      setElementStyleClass("snmpNumberOfRetries", "label");
	      setElementStyleClass("snmpTimeout", "label");
	      setElementStyleClass("snmpVersion", "label");
	    }
	}
	
	function setupInstallAgentAndUpdateAddress(localServiceEnabled)
    {
    	
       var localServiceChecked = localServiceEnabled;
       var boolInstallAgentDisabled = true;

       if (document.getElementById("monitorTypeId").checked == true){
       	  localServiceChecked = true;
       }
       
	   if(localServiceChecked == true) {
	      boolInstallAgentDisabled = false;
	   }
	   
       disableCollection(document.getElementsByName("installMonitoringAgent"), boolInstallAgentDisabled);
       disableCollection(document.getElementsByName("deviceIsUpdateable"), boolInstallAgentDisabled);
	   if(localServiceChecked == true) {
	      setElementStyleClass("unmanagedInstallAgentId", "label");
	      setElementStyleClass("updateLocalAddressId", "label");
	      document.forms[0].deviceIsUpdateable.checked = true;
	   }
	   else{
	      setElementStyleClass("unmanagedInstallAgentId", "disabledField");
	      setElementStyleClass("updateLocalAddressId", "disabledField");
	      document.forms[0].deviceIsUpdateable.checked = false;
	      document.forms[0].installMonitoringAgent.checked = false;
       }
	}
  //===============================================================
  // This is called on edit_service.jsp when discoValues are available
  // on same T_Parameter and one of discovered values is selected from the 
  // drop-down selection list
  //===============================================================
    function loadDiscoveredValue(){
    	var obj1 = document.forms[0].elements["discoveredValue"].value;
     	document.getElementById("servicePValue").value = obj1;
        document.forms[0].elements["discoveredValue"].value = "-1";
    }
    
  //===============================================================
  // Disable/ Enable 'Import', 'Ignore', 'Delete' buttons on
  // 'Discovered Assets' page based on Selected Devices
  //===============================================================
    function UpdateImportDiscoButtons(selectedFieldName) {
        objForm=document.forms[0];
	    selectedBox=objForm.elements[selectedFieldName];

	    if (selectedBox == null  || selectedBox.length  == 0){
	       	setElementStyleClass("importAssets", "disabledButton");
	       	setElementStyleClass("ignoreAssets", "disabledButton");
  	   		setElementStyleClass("deleteAssets", "disabledButton");
  	   		document.getElementById("importAssets").disabled=true;
  	   		document.getElementById("ignoreAssets").disabled=true;
			document.getElementById("deleteAssets").disabled=true;
	   }
	   else{
	   	 	setElementStyleClass("importAssets", "Button");
	   	 	setElementStyleClass("ignoreAssets", "Button");
  	  		setElementStyleClass("deleteAssets", "Button");
	   		document.getElementById("importAssets").disabled=false;
	   		document.getElementById("ignoreAssets").disabled=false;
			document.getElementById("deleteAssets").disabled=false;
	   }
	}
	
	//===============================================================
    // Initialize Windows Event Log rule 
    //===============================================================
	function initEventLogRule(rule){
		eventLogRuleChange(rule);
	}
	
	//===============================================================
    // Display Windows Event Log rule based on radio button selection
    //===============================================================
	function eventLogRuleChange(rule) {
		if (rule == 'AND'){
		    document.getElementById("ruleAnd").style.display = '';
		    document.getElementById("ruleOr").style.display = 'none';
		}else{
			document.getElementById("ruleAnd").style.display = 'none';
		    document.getElementById("ruleOr").style.display = '';
		}
	}
	
	//===============================================================
  // Hide and display expandable and collapsable elements on the page
  //===============================================================
		function toggleExpandableCollapsableElementDisplay(obj, img) {
		var el = document.getElementById(obj);
		if ( el.style.display != "none" ) {
			el.style.display = 'none';
		}
		else {
			el.style.display = '';
		}
		
		var e2 = document.getElementById(img);
		if(e2 != null) {
			if(e2.src.match('/images/blue_down_arrow.gif') != null) {
				e2.src = '/images/blue_up_arrow.gif';
			}
			else {
				e2.src = '/images/blue_down_arrow.gif';
			}
		}
		
	}
	
		
	 /**
 * Splits the text into <span> elements
 * @param the text to be parsed
 * @return array of <span> elements - this array can contain nulls
 */
 function splitTextIntoSpan(textToSplit){
 
  	//Split the document
 	returnElements=textToSplit.split("</span>")
 	
 	//Process each of the elements 	
 	for ( var i=returnElements.length-1; i>=0; --i ){
 		
 		//Remove everything before the 1st span
 		spanPos = returnElements[i].indexOf("<span");		
 		
 		//if we find a match , take out everything before the span
 		if(spanPos>0){
 			subString=returnElements[i].substring(spanPos);
 			returnElements[i]=subString;
 		
 		} 
 	}
 	
 	return returnElements;
 }
 
 /*
  * Replace html elements in the existing (ie viewable document)
  * with new elements (from the ajax requested document)
  * WHERE they have the same name AND are <span> elements
  * @param newTextElements (output of splitTextIntoSpan)
  *					in the format <span id=name>texttoupdate
  */
 function replaceExistingWithNewHtml(newTextElements){
 
 	//loop through newTextElements
 	for ( var i=newTextElements.length-1; i>=0; --i ){
  
 		//check that this begins with <span
 		if(newTextElements[i].indexOf("<span")>-1){
 			
 			//get the name - between the 1st and 2nd quote mark
 			startNamePos=newTextElements[i].indexOf('"')+1;
 			endNamePos=newTextElements[i].indexOf('"',startNamePos);
 			name=newTextElements[i].substring(startNamePos,endNamePos);
 			
 			//get the content - everything after the first > mark
 			startContentPos=newTextElements[i].indexOf('>')+1;
 			content=newTextElements[i].substring(startContentPos);
 			
 			//Now update the existing Document with this element
 			
	 			//check that this element exists in the document
	 			if(document.getElementById(name)){
	 				document.getElementById(name).innerHTML = content;
	 			} else {
	 				//alert("Element:"+name+"not found in existing document");
	 			}
 		}
 	}
 	
 }
 
 /* Nov View Advanced Filter: working with AJAX
  *
  */
  	function generate(array,element){
		var outcome = "";
		if( array != null && array.length > 0 ){
			for( var i=0; i<array.length; i++ ){
				outcome = outcome + element + "=" + array[i] + "&";
			}
		}else{
			outcome = outcome + element + "=null&";
		}
		return outcome;
	}
	
	function getSelectedValues(listName){
		selectedList = document.forms[0].elements[listName];
		var arSelected = new Array();
		if( selectedList != null ){
			var elements = selectedList.options.length;
			arSelected = new Array(elements);
			for( var i=0; i<elements; i++ ){
				arSelected[i] = escape(selectedList.options[i].text);
				selectedList.options[i].selected=false;
			}
		}
		return arSelected;
	}
	
	//============================================================
    // This is a general function to toggle on/off a tag (<span>, <div>)
    // divID represents the id of the tag
    // iState is true/false coresponding to on/off
    //============================================================
	function toggleTag(divID, iState) 
	{
		var obj = null;
    	if(document.layers)	   //NN4+
    	{
			obj = document.layers[divID];
    	}
    	else if(document.getElementById)	  //gecko(NN6) + IE 5+
    	{
    		obj = document.getElementById(divID);
    	}
    	else if(document.all)	// IE 4
    	{
    		obj = document.all[divID];
        }

        if (obj != null){
    		if (!iState){
    			obj.style.display = 'none';
    		}else{
    			obj.style.display = '';
    		}
    	}
	} 
	
	//============================================================
    // Disable the export from file section on load of import devices page
    //============================================================
	function initFileImport(value){
		if (value == 'true'){
			importDiscoveredAssets(false);
		}else{
			importDiscoveredAssets(true);
		}
		
		
	}
	
	//============================================================
    // Disable/ enable the 'import form file' or 'import assets sections' 
    // from the Import Device(s)
    //============================================================
	function importDiscoveredAssets(value){
	    var discoAssets = document.getElementById("importDiscoveredAssets");
	    var ignorAssets = document.getElementById("importIgnoredAssets");
   
		if (value){
			setElementStyleClass("importFileButton", "disabledButton");
			document.getElementById("importFileButton").disabled = true;
			document.getElementById("importFileField").disabled = true;
			setElementStyleClass("location", "disabledField");
			if (discoAssets != null){
				discoAssets.style.visibility = 'visible';
			}
			if (ignorAssets != null){
				ignorAssets.style.visibility = 'visible';
			}
		}else{
			setElementStyleClass("importFileButton", "Button");
  	   		document.getElementById("importFileButton").disabled = false;
  	   		document.getElementById("importFileField").disabled = false;
			setElementStyleClass("location", "label");
			if (discoAssets != null){
				discoAssets.style.visibility = 'hidden';
			}
			if (ignorAssets != null){
				ignorAssets.style.visibility = 'hidden';
			}
		}
	}
  
  //============================================================
    //toggleRSMDisabled -- used to toggle the correct
    // fields between disabled and enabled when the user selects
    // "Ask User Permission" for connection type "Remote Support Manager" in 
    // remote control sections
    //
    //Currently this will be called from the following jsps:
    // add_customer.jsp
    // edit_customer_details.jsp
    // edit_device_remote_control.jsp
    //
    // [askPermissionChecked] true if the "Ask User Permission" checkbox is
    // checked, false otherwise 
    //============================================================
  function toggleRSMDisabled(askPermissionChecked){
		disableCollection(document.getElementsByName("RSM_DoNotAskPermission"), !askPermissionChecked);
		disableCollection(document.getElementsByName("RSM_WarningText"), !askPermissionChecked);
		disableCollection(document.getElementsByName("RSM_WarningDuration"), !askPermissionChecked);
		disableCollection(document.getElementsByName("RSM_AllowRCAfterWarningTimeout"), !askPermissionChecked);
					
		if(!askPermissionChecked) {
			setElementStyleClass("RSM_DoNotAskPermission_Label", "DisabledField");
			setElementStyleClass("RSM_WarningText_Label", "DisabledField");
			setElementStyleClass("RSM_WarningDuration_Label", "DisabledField");
			setElementStyleClass("RSM_AllowRCAfterWarningTimeout_Label", "DisabledField");
			setElementStyleClass("seconds", "DisabledField");				      
		}
		else {
			setElementStyleClass("RSM_DoNotAskPermission_Label", "label");
			setElementStyleClass("RSM_WarningText_Label", "label");
			setElementStyleClass("RSM_WarningDuration_Label", "label");
			setElementStyleClass("RSM_AllowRCAfterWarningTimeout_Label", "label");
			setElementStyleClass("seconds", "label");
		}
	}
	
	 //============================================================
	 // Device Downtime section
	 // Update the days of month on month selection
	 //============================================================
	function updateDaysOnMonthChange(theForm, elementId){
		var daysInMonth= new Array(0,31,28,31,30,31,30,31,31,30,31,30,31);
	    var index = "";
	    var dayValues = "";
	    var dayElement = "";
    	if (elementId == 'onceStartDayId'){
    		index = theForm.onceStartMonth.value;
			dayElement = "<select name=\"onceStartDay\" size=\"1\" class=\"Label\">";
		}
		else if (elementId == 'onceEndDayId'){
		    index = theForm.onceEndMonth.value;
			dayElement = "<select name=\"onceEndDay\" size=\"1\" class=\"Label\">";
		}
		
		var year = 0;		
		var currDaysInMonth = daysInMonth[index];
		
		if (index == 2){ // month of february
		    if (elementId == 'onceStartDayId'){
		    	year = theForm.onceStartYear.value;
		    }else if (elementId == 'onceEndDayId'){
		    	year = theForm.onceEndYear.value;
		    }
			if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year
				currDaysInMonth = 29;
			}
		}
		
		for (var i=1; i <= currDaysInMonth; i++) {
			dayValues += "<option value=" + i + ">" + i + "</option>";
		}
        document.getElementById(elementId).innerHTML = dayElement + dayValues + "</select>";
	}
	
	//============================================================
	// Device Downtime section
	// Update the year on month selection. If the month is before current month
	// the returned year is current year + 1, otherwise current year will be returned
	// All calculation is done related to the current time of the server
	//===========================================================
	function updateYearOnMonthChange(theForm, elementId){
		var year = 0;
		var now = null;
		var systemTime = theForm.serverTime.value; // server time
	    if (systemTime != null && systemTime > 0){
	    	now = new Date(systemTime);
	    }else{
		    now = new Date();
		}
        var currentMonth=now.getMonth()+1;
        var currentYear=now.getFullYear();
        if (elementId == 'onceStartDayId'){
	        if (theForm.onceStartMonth.value > currentMonth){
    	    	theForm.onceStartYear.value = currentYear;
    	    	document.getElementById('onceStartYearId').value = currentYear;
        	}else if (theForm.onceStartMonth.value < currentMonth){
        		theForm.onceStartYear.value = currentYear + 1; 
        		document.getElementById('onceStartYearId').value = currentYear + 1;
	        }else if (theForm.onceStartMonth.value == currentMonth){
	        	document.getElementById('onceStartYearId').value = currentYear;
    	    	theForm.onceStartYear.value = currentYear;
        		theForm.onceStartDay.value = now.getDate();
        	}
        	if (theForm.onceStartMonth.value == 2){ // month of february
				updateDaysOnMonthChange(theForm, 'onceStartDayId');
			}
        }else if (elementId == 'onceEndDayId'){
	        if (theForm.onceEndMonth.value > currentMonth){
    	    	theForm.onceEndYear.value = currentYear;
    	    	document.getElementById('onceEndYearId').value = currentYear;
        	}else if (theForm.onceEndMonth.value < currentMonth){
        		theForm.onceEndYear.value = currentYear + 1; 
        		document.getElementById('onceEndYearId').value = currentYear + 1; 
        	}else if(theForm.onceEndMonth.value == currentMonth){
	        	document.getElementById('onceEndYearId').value = currentYear;
	        	theForm.onceEndYear.value = currentYear;
	        	theForm.onceEndDay.value = now.getDate();
        	}
        	if (theForm.onceStartMonth.value == 2){ // month of february
				updateDaysOnMonthChange(theForm, 'onceEndDayId');
			}
        }
	}
	
	//==========================================================================
	// Device Downtime section
	// Update the year on day selection - downtime section. If the selected month 
	// same as current month and the selected day before current day the returned year
	// is current year + 1, otherwise current year will be returned
	// All calculation is done related to the current time of the server
	//============================================================================
	function updateYearOnDayChange(theForm, flag){
		var now = null;
		var systemTime = theForm.serverTime.value; // server time
		if (systemTime != null && systemTime > 0){
	    	now = new Date(systemTime);
	    }else{
		    now = new Date();
		}
		var currentDay = now.getDate();
		var currentHour = now.getHours();
        var currentYear = now.getFullYear();
        var currentMonth = now.getMonth()+1;
        if (flag == 'onceStart'){
        	if (theForm.onceStartMonth.value == currentMonth){
        		if (theForm.onceStartDay.value < currentDay){
	       			theForm.onceStartYear.value = currentYear + 1;
	       			document.getElementById('onceStartYearId').value = currentYear + 1;
	       			
        		} else{
        			theForm.onceStartYear.value = currentYear;
        			document.getElementById('onceStartYearId').value = currentYear;
        		}
        	}
        }
        if (flag == 'onceEnd'){
        	if (theForm.onceEndMonth.value == currentMonth){
        		if (theForm.onceEndDay.value < currentDay){
	       			theForm.onceEndYear.value = currentYear + 1;
	       			document.getElementById('onceEndYearId').value = currentYear + 1; 
        		} else{
        			theForm.onceEndYear.value = currentYear;
        			document.getElementById('onceEndYearId').value = currentYear; 
        		}
        	}
        }
	}
	
	//==========================================================================
	// Device Downtime section
	// Update the days of month and year on month selection
	//==========================================================================
	function updateDaysYearOnMonthChange(theForm, elementId){
		updateDaysOnMonthChange(theForm, elementId);
		updateYearOnMonthChange(theForm, elementId);
	}
	//for add_device.jsp
	function showAutomaticDisconnection(theForm, autoDisconnection){
			var monitorType = theForm.elements['monitorType'];
			var element = document.getElementById('automaticDisconnection');
			if( monitorType != null && monitorType.checked ){
				//hide the disconnected section	
				var deviceClass = theForm.elements['deviceClass'].value;
				var ignoreAutomaticDisconnect = autoDisconnection;			
		   		element.style.display = '';
		   	}else{
		   		element.style.display = 'none';
		   	}			
   	}


   	//for edit_device.jsp and import_asset_edit_devices.jsp
    function showDisconnectedSection(theForm, autoDisconnetion){
	   		var monitorType = theForm.elements['monitorType'];	   	
	   		var element = document.getElementById('automaticDisconnection');
	   		var label = document.getElementById('automaticDisconnectionLabel');
	   		if( monitorType != null && monitorType.checked ){
				//hide the disconnected section				
				var deviceClass = theForm.elements['deviceClass'].value;
				var ignoreAutomaticDisconnect = autoDisconnetion;		
				element.style.visibility = 'visible';
		   		label.style.visibility = 'visible';	
		   	 } else {
		   	 	element.style.visibility = 'hidden';
		   		label.style.visibility = 'hidden';	   	
		   	 }   
	   	}
   	
   	  //for edit_device.jsp
   	  function editLocalAgent(theForm, type, version, winnt) { 
             var installAgent=document.getElementById('MainFrame'); 
             var monitorType = theForm.elements['monitorType']; 
             var installMonitoringAgent= theForm.elements['installMonitoringAgent']; 
             var renderInstallAgent=document.getElementById('renderInstallAgent'); 
             var renderUninstallAgent=document.getElementById('renderUninstallAgent'); 
             var imaInitChecked=false; 
             var imaChecked = true;
             var rebootid=document.getElementById('reboot'); 
             if(!installAgent)return true; 
             if (type == 'monitorType') { 
                 if (version==null || version!=null && version.length==0 ) { 
                             if( monitorType != null && monitorType.checked ){ 
                               if (winnt == 'winnt') { 
                                       installAgent.style.display="inline"; 
                                       if (renderInstallAgent != null) { 
                                           renderInstallAgent.style.display="inline"; 
                                           } 
                                       if (renderUninstallAgent != null) { 
                                           renderUninstallAgent.style.display="none"; 
                                       } 
                               } 
                             } else { 
                                   if (installMonitoringAgent !=null && installMonitoringAgent.checked) { 
                                       installMonitoringAgent.checked = imaInitChecked; 
                                   disableCollection(document.getElementsByName("installWspId"), imaChecked); 
                               } 
                               installAgent.style.display="none"; 
		    				   rebootid.style.display="none";
                                
                               if (winnt == 'winnt') { 
                                       if (renderUninstallAgent != null) { 
                                           renderUninstallAgent.style.display="inline"; 
                                       } 
                               } 
                            } 
                            return true; 
                     } else if (version!=null && version.length>0) { 
                             if( monitorType != null && monitorType.checked ){ 
                               installAgent.style.display="none"; 
                               if (renderUninstallAgent !=null) 
                                   renderUninstallAgent.style.display="none"; 
                              } else { 
                                   if (winnt == 'winnt') { 
                                  installAgent.style.display="inline"; 
                                      if (renderUninstallAgent != null) 
                                           renderUninstallAgent.style.display="inline"; 
                                      } 
                                   } 
                                   if (installMonitoringAgent !=null) { 
                                      installMonitoringAgent.checked = imaInitChecked; 
                                  disableCollection(document.getElementsByName("installWspId"), imaChecked); 
                               } 
                                   return true; 
                           } 
              } 
              if (type=='installMonitoringAgent') { 
                if (installMonitoringAgent !=null && installMonitoringAgent.checked) { 
                   imaChecked = false; 
                   rebootid.style.display="inline";
                } else{
	      			rebootid.style.display="none";	
	     		}  
                disableCollection(document.getElementsByName("installWspId"), imaChecked); 
              } 
           } 
           //for edit_device.jsp 
           function RenderUninstallMsg(theForm) { 
                    var uninstallAgentMsgId=document.getElementById('UninstallAgentMsg'); 
                    var monitorType = theForm.elements['monitorType']; 
                    if (monitorType != null && monitorType.checked) { 
                           if (uninstallAgentMsgId != null) 
                                   uninstallAgentMsgId.style.display="none"; 
                    }else { 
                           if (uninstallAgentMsgId != null) 
                                   uninstallAgentMsgId.style.display="inline"; 
                    } 
           } 
   	
   	//---Check CapsLockOn in login.jsp for the password field

	function checkCapsLock( e ) {
		var myKeyCode=0;
		var myShiftKey=false;		
		var divi=document.getElementById("warningDivPasswordCapsLockOn");
		
		//if the browser did not pass event information to the handler,check in window.event
		if( !e ) { 
			e = window.event; 
		} 
		if( !e ) { 
			return; 
		}
		
		//Netscape 4+, etc.
		if ( e.which ) { 
			myKeyCode = e.which; 
		}
		//Internet Explorer, etc. 
  		else if ( e.keyCode ) { 
  			myKeyCode = e.keyCode; 
  		} 
		//Geko Browsers (Firfox, Camino)
		else if( e.charCode ) {
			myKeyCode = e.charCode; 
		}

  		//Internet Explorer, etc.
  		if( e.shiftKey ) { 
  			myShiftKey = e.shiftKey; 
  		//Netscape 4
  		} else if ( e.modifiers ) { 
    		//check the third bit of the modifiers value (says if SHIFT is pressed)
    		if( e.modifiers & 4 ) { //bitwise AND
      			myShiftKey = true;
    		}
  		}
  		
	
		// Upper case letters are seen without depressing the Shift key, therefore Caps Lock is on
		if ( myKeyCode > 64 && myKeyCode < 91  && !myShiftKey ) {
			divi.style.display = "inline";
		// Lower case letters are seen while depressing the Shift key, therefore Caps Lock is on
		} else if ( myKeyCode > 96 && myKeyCode < 123 && myShiftKey ) {
			divi.style.display = "inline";
		}
		else{
			divi.style.display = "none";
		}
	}
	
	//==========================================================================
	// Asset Discovery - edit single device section
	// Toggle the Update Monitored Address field
	//==========================================================================
	function toggleUpdateAddressOnUnmanagedDevices(){
		if (document.forms[0].deviceIsUpdateable != undefined){
			var boolUpdateAddressDisabled = true;
			if (document.forms[0].monitorType.checked == true){
				boolUpdateAddressDisabled = false;
			}
			disableCollection(document.getElementsByName("deviceIsUpdateable"), boolUpdateAddressDisabled);
			if (boolUpdateAddressDisabled == false){
				setElementStyleClass("updateLocalAddressId", "label");
				document.forms[0].deviceIsUpdateable.checked = true;
			}else{
				setElementStyleClass("updateLocalAddressId", "disabledField");
				document.forms[0].deviceIsUpdateable.checked = false;
			}
		}
	}
	
	//==========================================================================
	// Asset Discovery - edit single device section
	// Set the Update Monitored Address field
	//==========================================================================
	function setupUpdateAddressOnUnmanagedDevices(updateFlag, monitorFlag){
	    
	 	if (document.forms[0].deviceIsUpdateable != undefined){
			if (updateFlag == 'true'){
				setElementStyleClass("updateLocalAddressId", "label");
				document.forms[0].deviceIsUpdateable.checked = true;
			}else{
				if (monitorFlag == 'true'){
					setElementStyleClass("updateLocalAddressId", "label");
					disableCollection(document.getElementsByName("deviceIsUpdateable"), false);
				}else{
					setElementStyleClass("updateLocalAddressId", "disabledField");
					disableCollection(document.getElementsByName("deviceIsUpdateable"), true);
				}
				document.forms[0].deviceIsUpdateable.checked = false;
			}
		}
	}
	
   //For event_log.jsp, Filter Events
   function enableFilter(theForm){
	 var element = document.getElementById("RenderEventSources");
	 //var filtered = theForm.elements['filtered'];
	 //var chk = document.getElementByName("EnableFilters");
	 var checked  = 0;
	 if ( element.style.display == "none" ) {
	 	checked  = 1;
	 }
	 
	 if ( checked == 0 ) {
	 	element.style.display = "none";
	 }  
	 else {
	 	element.style.display = "block";
	 }
	 return true;
  } 

