function GetControl(controlID)
{
    var control = document.getElementById(controlID);
    if (control == null)
        alert("Unable to locate control: " + controlID);
    
    return control;
}

function IsIEBrowser()
{
	if (navigator.appName.indexOf("Microsoft") != -1)
		return true;
	else
		return false;
}

function ToggleInputImageSrc(inputCtrlID, enabledImage, disabledImage, enabled)
{
    var inputCtrl = document.getElementById(inputCtrlID);
    if (enabled)
        inputCtrl.src = enabledImage;
    else
        inputCtrl.src = disabledImage;
}

// Params area object constructor
function RSParameters(disabledColor, disabledStyle, enabledStyle, parametersGridID, credentialLinkID)
{
    this.m_disabledColor = disabledColor;
    this.m_disabledStyle = disabledStyle;
    this.m_enabledStyle = enabledStyle;
    this.m_parametersGridID = parametersGridID;
    this.m_credentialLinkID = credentialLinkID;
}

// Update the state of a nullable parameter.
function UpdateParam1(nullChkID, param1ID)
{
    this.UpdateParam2(nullChkID, param1ID, null);
}
RSParameters.prototype.UpdateParam1 = UpdateParam1;

function UpdateParam2(nullChkID, param1ID, param2ID)
{
    if (!IsIEBrowser)
        return;
        
    // Get the interesting controls
    var nullChkBox = GetControl(nullChkID);
    if (nullChkBox == null)
        return;
    var param1Control = GetControl(param1ID);
    if (param1Control == null)
        return;
    var param2Control = null;
    if (param2ID != null)
    {
        param2Control = GetControl(param2ID);
        if (param2Control == null)
            return;
    }        

	// If the null checkbox itself is not enabled, don't change the state
	// of the parameter controls.  The null check box is disabled when
	// a data driven parameter has an outstanding dependencies
	if (nullChkBox.disabled)
		return;

    // Enable/Disable the other controls
    this.DisableInput(param1Control, nullChkBox.checked);
    if (param2Control != null)
        this.DisableInput(param2Control, nullChkBox.checked);
}
RSParameters.prototype.UpdateParam2 = UpdateParam2;

function DisableInput(control, shouldDisable)
{
    if (control.type == "text")         // Enable/disable a text box
    {
        this.DisableTextInput(control, shouldDisable);
    }
    else if (control.type == "radio")   // Enable/disable a radio button
    {
        // ASP sets the disabled tag on a span that contains the radio button
        control.parentNode.disabled = shouldDisable;    
    }
    else
        control.disabled = shouldDisable;
}
RSParameters.prototype.DisableInput = DisableInput;

function DisableReportViewerTextInput(control, shouldDisable)
{
    var useClass = this.m_disabledStyle != "" || this.m_enabledStyle != "";
    if (shouldDisable)
    {
        if (useClass)
            control.className = this.m_disabledStyle;
        else
	        control.style.backgroundColor = this.m_disabledColor;
    }
    else
    {
        if (useClass)
            control.className = this.m_enabledStyle;
        else
	        control.style.backgroundColor = "";
    }
    
    control.disabled = shouldDisable;
}
RSParameters.prototype.DisableTextInput = DisableReportViewerTextInput;

function RSP_HideActiveDropDown()
{
    if (this.ActiveDropDown != null)
        this.ActiveDropDown.Hide();
}
RSParameters.prototype.HideActiveDropDown = RSP_HideActiveDropDown;

function RSP_OnActiveDropDownHidden(previouslyVisibleDropDown)
{
    // Check that it is still listed as active, in case event ordering
    // caused the show on the new one to fire first
    if (this.ActiveDropDown == previouslyVisibleDropDown)
        this.ActiveDropDown = null;
}
RSParameters.prototype.OnActiveDropDownHidden = RSP_OnActiveDropDownHidden;

function RSP_SetNewActiveDropDown(newDropDown)
{
    // Hide the previously visible dropDown
    if (this.ActiveDropDown != newDropDown && this.ActiveDropDown != null)
        this.ActiveDropDown.Hide();

    this.ActiveDropDown = newDropDown;
}
RSParameters.prototype.SetNewActiveDropDown = RSP_SetNewActiveDropDown;

function OnChangeCredentialsClicked()
{
    // Hide the link
    event.srcElement.style.display = "none";
    
    // Make sure each row in the table is visible
    var paramsTable = GetControl(this.m_parametersGridID);
    for (var i = 0; i < paramsTable.rows.length; i++)
    {
        var row = paramsTable.rows[i];
        if (row.IsParameterRow != "true")
            row.style.display = "inline";
        else
            row.style.display = "none";
    }
}
RSParameters.prototype.OnChangeCredentialsClicked = OnChangeCredentialsClicked;

function ShouldValidateCredentials()
{
    // Get the credential link
    var credentialLink = document.getElementById(this.m_credentialLinkID);
    
    // The credential link is not rendered in 2 cases.
    // 1 - There are no credentials.  This method is only called when validating
    //     credentials.  So this method won't get called in this case.
    // 2 - The credential prompts are being shown initially because they aren't
    //     satisfied.  In this case, we always want to validate the input boxes.
    if (credentialLink == null)
        return true;

    // Switched back from intial view of parameters to credentials
    return credentialLink.style.display == "none";
}
RSParameters.prototype.ShouldValidateCredentials = ShouldValidateCredentials;

function ShouldValidateParameters()
{
    // Get the credential link
    var credentialLink = document.getElementById(this.m_credentialLinkID);
    // The credential link is not rendered in 2 cases.
    // 1 - There are no credentials.  This method is only called when validating
    //     parameters.  If there are no credentials, the parameters must be visible
    //     and should be validated
    // 2 - The credential prompts are being shown initially because they aren't
    //     satisfied.  In this case, there are no rendered parameter prompts, so
    //     this method won't get called.
    if (credentialLink == null)
        return true;

    // Initial view was of parameters and it still is
    return credentialLink.style.display != "none";
}
RSParameters.prototype.ShouldValidateParameters = ShouldValidateParameters;

function ValidateCredential(userID, errMsg)
{
    // If the credentials are not visible, we don't need to validate them.
    if (!this.ShouldValidateCredentials())
        return true;
        
    var userControl = GetControl(userID);
    if (userControl.value == "")
    {
        alert(errMsg);
        return false;
    }
    return true;
}
RSParameters.prototype.ValidateCredential = ValidateCredential;

// Validate that the parameter has a non-empty value
function ValidateHasValue(paramID, nullChkID, errmsg)
{
    // If the parameters are not visible, we don't need to validate them.
    if (!this.ShouldValidateParameters())
        return true;

	if (nullChkID != "" && (document.getElementById(nullChkID).checked == true))
		return true;
	var paramValue = document.getElementById(paramID).value;
	if ((paramValue == null) || (paramValue == ""))
	{
		alert(errmsg);
		return false;
	}
	return true;
}
RSParameters.prototype.ValidateHasValue = ValidateHasValue;

function DoesInputHaveValue(elementID)
{
    var element = document.getElementById(elementID);
    
    if (element.value != null && element.value != "")
        return true;
    
    return false;
}
RSParameters.prototype.DoesInputHaveValue = DoesInputHaveValue;

function DoesBooleanHaveValue(trueID, falseID)
{
    var trueElement = document.getElementById(trueID);
    var falseElement = document.getElementById(falseID);
    
    if (trueElement.checked || falseElement.checked)
        return true;
    
    return false;
}
RSParameters.prototype.DoesBooleanHaveValue = DoesBooleanHaveValue;

// Validate a drop down list
function ValidateDropDown(paramID, errMsg, hasInitialBlank)
{
    // If the parameters are not visible, we don't need to validate them.
    if (!this.ShouldValidateParameters())
        return true;

	// The first item is a blank place holder
	if (hasInitialBlank)
	{
		var dropDown = document.getElementById(paramID);
		if (dropDown.selectedIndex == 0)
		{
			alert(errMsg);
			return false;
		}
	}
	
	return true;
}
RSParameters.prototype.ValidateDropDown = ValidateDropDown;

function ValidateBoolean(trueID, falseID, nullChkID, errmsg)
{
    // If the parameters are not visible, we don't need to validate them.
    if (!this.ShouldValidateParameters())
        return true;

	if (nullChkID != "" && (document.getElementById(nullChkID).checked == true))
		return true;
	var trueChecked = document.getElementById(trueID).checked;
	var falseChecked = document.getElementById(falseID).checked;
	if (!trueChecked && !falseChecked)
	{
		alert(errmsg);
		return false;
	}
	return true;
}
RSParameters.prototype.ValidateBoolean = ValidateBoolean;

// Report class constructor
function RSReport(clientController, reportPrefix, reportDivID, reportCellID, initialZoomValue, navigationId, pageNumber, totalPages,
                  hasDocMap, searchStartPage, autoRefreshAction, autoRefreshInterval, searchText)
{
    this.m_clientController = clientController;
    this.m_reportPrefix = reportPrefix;
    this.m_reportDivID = reportDivID;
    this.m_reportCellID = reportCellID;
    this.m_initialZoomValue = initialZoomValue;
    this.m_navigationId = navigationId;
    this.m_pageNumber = pageNumber;
    this.m_totalPages = totalPages;
    this.m_hasDocMap = hasDocMap;
    this.m_nextHit = 1;
    this.m_searchStartPage = searchStartPage;
    this.m_autoRefreshAction = autoRefreshAction;
    this.m_autoRefreshInterval = autoRefreshInterval;
    this.m_searchText = searchText;
}

function OnLoadReport(reloadDocMap)
{
    this.m_clientController.OnReportLoaded(this, reloadDocMap);

    if (null != this.m_navigationId && this.m_navigationId != "")
        window.location.replace("#" + this.m_navigationId);
        
    if (this.m_autoRefreshAction != null)
        setTimeout(this.m_autoRefreshAction, this.m_autoRefreshInterval);
}
RSReport.prototype.OnLoadReport = OnLoadReport;

function UpdateZoom(paramZoomValue)
{
    if (paramZoomValue != null)
        zoomValue = paramZoomValue;
    else if (this.m_lastZoomValue != null)
        zoomValue = this.m_lastZoomValue;
    else
        // Zoom should be set initially during OnLoad.  Until then, ignore calls from toolbar/resize event
        return;

    // Get the report cell
	var reportCell = GetControl(this.m_reportCellID);
	if (reportCell == null)
	    return;

	if ((zoomValue != "PageWidth") && (zoomValue != "FullPage"))
		reportCell.style.zoom = zoomValue + "%";
	else
	{
	    // Get the report div
	    var reportDiv = GetControl(this.m_reportDivID);
	    if (reportDiv == null)
	        return;
	    
		if (zoomValue != "PageWidth")
		{
			if ((reportCell.offsetWidth * reportDiv.offsetHeight) < (reportCell.offsetHeight * reportDiv.offsetWidth))
				SetZoom(reportCell, reportDiv.offsetHeight, reportCell.offsetHeight);
			else
				SetZoom(reportCell, reportDiv.offsetWidth, reportCell.offsetWidth);
		}
		else
		{
			var vbar = reportDiv.offsetHeight != reportDiv.clientHeight;
			var proceed = (reportCell.offsetWidth > 0);
			for (var iter = 0; (iter <= 1) & proceed; ++iter)
			{
				zoomValue = SetZoom(reportCell, reportDiv.clientWidth, reportCell.offsetWidth);
				proceed = vbar != ((reportCell.offsetHeight * zoomValue) > reportDiv.offsetHeight);
			}
		}
	}
	
	if (paramZoomValue != null)
        this.m_lastZoomValue = paramZoomValue;
}
RSReport.prototype.UpdateZoom = UpdateZoom;

function ActionHandler(actionType, actionParam)
{
    var completeActionParam;
    if (actionType == "Sort")    
    {
        if (window.event && window.event.shiftKey) 
            completeActionParam = actionParam + "_T";
        else
            completeActionParam = actionParam + "_F";
    }
    else
        completeActionParam = actionParam;
        
    return this.m_clientController.ActionHandler(actionType, completeActionParam);
}
RSReport.prototype.ActionHandler = ActionHandler;

// Zoom to the ratio specified by div / rep.
function SetZoom(reportCell, div, rep)
{
	if (rep <= 0)
		return 1.0;
	var z = (div - 1) / rep;
	reportCell.style.zoom = z;
	return z;
}

function ReportFindNext ()
{
	// Unhighlight previous hit, if any.
	if (this.m_nextHit > 0)
	{
		var hitElem = document.getElementById(this.m_reportPrefix + "oHit" + (this.m_nextHit - 1));
		if (hitElem != null)
		{
			hitElem.style.backgroundColor = "";
			hitElem.style.color = "";
		}
	}

    // Highlight current hit and navigate to it.
	var hitElem = document.getElementById(this.m_reportPrefix + "oHit" + this.m_nextHit);
	if (hitElem == null)
	    return false;
	hitElem.style.backgroundColor = "highlight";
	hitElem.style.color = "highlighttext";
	window.location.replace("#" + this.m_reportPrefix + "oHit" + this.m_nextHit);

    this.m_nextHit ++;

    return true;
}
RSReport.prototype.FindNext = ReportFindNext

function OnFrameVisible()
{
    // In async mode, fit proportional must happen after the report frame
    // becomes visible, otherwise images dimensions are 0.  In sync mode
    // it is handled inline in the renderer.
    if (typeof(ResizeImages) == "function") // Make sure it is defined
        ResizeImages();

    this.UpdateZoom(this.m_initialZoomValue);    
}
RSReport.prototype.OnFrameVisible = OnFrameVisible

// The client side viewer controller
function RSClientController(waitControlID, docMapReportFrameID, docMapUrl, docMapSize,
                            docMapVisible, baseReportPageUrl, canHandlePageNavOnClient, canHandleToggleOnClient,
                            canHandleSortOnClient, canHandleBookmarkOnClient, canHandleDocMapOnClient,
                            canHandleSearchOnClient, clientCurrentPageID,
                            canHandleRefreshOnClient, exportUrlBase, printFrameId, printHtmlLink,
                            docMapVisibilityStateID, promptAreaRowId, promptVisibilityStateId)
{
    this.m_waitControlID = waitControlID;
    this.m_docMapReportFrameID = docMapReportFrameID;
    this.m_docMapUrl = docMapUrl;
    this.m_docMapSize = docMapSize;
    this.m_docMapVisible = docMapVisible;
    this.m_baseReportPageUrl = baseReportPageUrl;
    this.m_canHandlePageNavOnClient = canHandlePageNavOnClient;
    this.m_canHandleToggleOnClient = canHandleToggleOnClient;
    this.m_canHandleSortOnClient = canHandleSortOnClient;
    this.m_canHandleBookmarkOnClient = canHandleBookmarkOnClient;
    this.m_canHandleDocMapOnClient = canHandleDocMapOnClient;
    this.m_canHandleRefreshOnClient = canHandleRefreshOnClient;
    this.m_clientCurrentPageID = clientCurrentPageID;
    this.m_canHandleSearchOnClient = canHandleSearchOnClient;
    this.m_exportUrlBase = exportUrlBase;
    this.m_printFrameId = printFrameId;
    this.m_printHtmlLink = printHtmlLink;
    this.m_docMapVisibilityStateID = docMapVisibilityStateID;
    this.m_promptAreaRowId = promptAreaRowId;
    this.m_promptVisibilityStateId = promptVisibilityStateId;
    this.m_reportLoaded = false;

    // Calculated property    
    if (this.m_docMapReportFrameID == "")
        this.IsAsync = false;
    else
        this.IsAsync = true;
}

function ControllerActionHandler(actionType, actionParam)
{
    // Don't allow empty search
    if ((actionType == "Search" || actionType == "SearchNext") &&
        (actionParam == null || actionParam == ""))
        return;

    if (this.CanHandleClientSideAction(actionType))
    {
        // Construct the url
        var actionUrl = this.m_baseReportPageUrl + "&" + this.CommonReportPageQueryParams();
        actionUrl += "&ActionType=" + encodeURIComponent(actionType);
        actionUrl += "&ActionParam=" + encodeURIComponent(actionParam);
        if (this.CurrentPage != null)
            actionUrl += "&PageNumber=" + encodeURIComponent(this.CurrentPage);
        
        // Sort can change the document map
        if (actionType == "Sort")
            actionUrl += "&ReloadDocMap=" + "true";

        // Set report frame
        this.PerformClientSidePageChange(actionUrl);
    }
    else
        return this.PostBackAction(actionType, actionParam);
}
RSClientController.prototype.ActionHandler = ControllerActionHandler;

function CanHandleClientSideAction(actionType)
{
    if (actionType == "Toggle")
        return this.m_canHandleToggleOnClient;
    else if (actionType == "Bookmark")
        return this.m_canHandleBookmarkOnClient;
    else if (actionType == "DocumentMap")
        return this.m_canHandleDocMapOnClient;
    else if (actionType == "Sort")
        return this.m_canHandleSortOnClient;
    else if (actionType == "Search")
        return this.m_canHandleSearchOnClient;
    else if (actionType == "SearchNext")
        return this.m_canHandleSearchOnClient;
    else if (actionType == "Refresh")
        return this.m_canHandleRefreshOnClient;
    else if (actionType == "PageNav")
        return this.m_canHandlePageNavOnClient;
    else
        return false; // Drillthrough
}
RSClientController.prototype.CanHandleClientSideAction = CanHandleClientSideAction;

function OnReportLoaded(reportObject, reloadDocMap)
{
    this.m_reportObject = reportObject;
    this.CurrentPage = reportObject.m_pageNumber;
    this.TotalPages = reportObject.m_totalPages;
    this.m_searchStartPage = reportObject.m_searchStartPage;

    // Update the client side page number so that it is available to the server object
    // if it was changed asynchronously.
    var clientCurrentPage = GetControl(this.m_clientCurrentPageID);
    if (clientCurrentPage != null)
        clientCurrentPage.value = this.CurrentPage;
    
    // If there is a document map, display it
    if (this.HasDocumentMap())
    {
        // This method is called each time the report loads.  This happens
        // for page navigations and report actions.  For many of these cases,
        // the doc map didn't change, so don't reload it.
        if (reloadDocMap)
        {
            if (this.CanDisplayBuiltInDocMap() && this.m_docMapUrl != "")
            {
                var docMapReportFrame = frames[this.m_docMapReportFrameID];
                docMapReportFrame.frames["docmap"].location.replace(this.m_docMapUrl);
            }

            this.CustomOnReloadDocMap();
        }

        if (this.m_docMapVisible && this.CanDisplayBuiltInDocMap())
            this.SetDocMapVisibility(true);
    }
    
    this.CustomOnReportLoaded();
}
RSClientController.prototype.OnReportLoaded = OnReportLoaded;

function OnReportFrameLoaded()
{
	this.m_reportLoaded = true;
    this.ShowWaitFrame(false);
 
    if (this.IsAsync && this.m_reportObject != null)
        this.m_reportObject.OnFrameVisible();
}
RSClientController.prototype.OnReportFrameLoaded = OnReportFrameLoaded;

function RVCC_CanDisplayBuiltInDocMap()
{
    return this.IsAsync;
}
RSClientController.prototype.CanDisplayBuiltInDocMap = RVCC_CanDisplayBuiltInDocMap;

function RVCC_HasDocumentMap()
{
    if (this.m_reportObject != null)
        return this.m_reportObject.m_hasDocMap;
    else
        return false;
}
RSClientController.prototype.HasDocumentMap = RVCC_HasDocumentMap;

function DelegateZoomChange(zoomValue)
{
    this.m_reportObject.UpdateZoom(zoomValue);
    
    // Set the zoom value to the last one on the report object instead
    // of the parameter so that it only gets set if it is valid.
    this.m_zoomValue = this.m_reportObject.m_lastZoomValue;
}
RSClientController.prototype.SetZoom = DelegateZoomChange;

function RSCC_CurrentZoom()
{
    var zoomValue = null;
    if (this.m_zoomValue != null)
        zoomValue = this.m_zoomValue; // Might be null if zoom was never changed on the client
    if (zoomValue == null && this.m_reportObject != null)
        zoomValue = this.m_reportObject.m_initialZoomValue;
    if (zoomValue == null)
        zoomValue = "100";
    
    return zoomValue;
}
RSClientController.prototype.CurrentZoom = RSCC_CurrentZoom;

function ShowInitialWaitFrame()
{
	if (!this.m_reportLoaded)
		this.ShowWaitFrame(true);
}
RSClientController.prototype.ShowInitialWaitFrame = ShowInitialWaitFrame;

function ShowWaitFrame(startShowingWaitFrame)
{
    // Check for synchronous processing
    if (!this.IsAsync)
        return;
        
    var waitControl = document.getElementById(this.m_waitControlID);
    if (!waitControl)
        return;

    var reportFrame = GetControl(this.m_docMapReportFrameID);
    
    if (startShowingWaitFrame)
    {
        waitControl.style.display = "inline";
        reportFrame.style.display = "none";
    }
    else
    {
        waitControl.style.display = "none";
        reportFrame.style.display = "inline";
    }
}
RSClientController.prototype.ShowWaitFrame = ShowWaitFrame;

function SetDocMapVisibility(makeVisible)
{
    var docMapReportFrame = frames[this.m_docMapReportFrameID];
    var frameset = docMapReportFrame.GetFrameSet();
    var reportFrame = docMapReportFrame.GetReportFrame();
    var docMapVisibilityState = document.getElementById(this.m_docMapVisibilityStateID);

    if (makeVisible)
    {
        frameset.cols = this.m_docMapSize + ",*";
        frameset.frameSpacing = "3";
        reportFrame.noResize = null;
        docMapVisibilityState.value = "false";
    }
    else
    {
        frameset.cols = "0,*";
        frameset.frameSpacing = "0";
        reportFrame.noResize = "true";
        docMapVisibilityState.value = "true";
    }

    this.m_docMapVisible = makeVisible;

    this.CustomOnDocMapVisibilityChange();
}
RSClientController.prototype.SetDocMapVisibility = SetDocMapVisibility;

function IsDocMapVisible()
{
    var docMapReportFrame = frames[this.m_docMapReportFrameID];
    if (docMapReportFrame == null)
        return false;

    var reportFrame = docMapReportFrame.GetReportFrame();
    if (reportFrame == null)
        return false;

	return !reportFrame.noResize;
}
RSClientController.prototype.IsDocMapVisible = IsDocMapVisible;

function RSCC_HandleSearchNext()
{
    if (this.m_reportObject != null)
    {
        if (!this.m_reportObject.FindNext())
            this.ActionHandler("SearchNext", this.m_searchStartPage + "_" + this.m_reportObject.m_searchText);
    }
}
RSClientController.prototype.HandleSearchNext = RSCC_HandleSearchNext;

function RSCC_CanContinueSearch()
{
    if (this.m_reportObject != null)
        return this.m_reportObject.m_searchStartPage > 0;
    else
        return false;
}
RSClientController.prototype.CanContinueSearch = RSCC_CanContinueSearch;

function PerformClientSidePageChange(url)
{
    this.CustomOnAsyncPageChange();

    // Get the report frame and set the url
    var docMapReportFrame = frames[this.m_docMapReportFrameID];
    var reportFrame = docMapReportFrame.frames["report"];
    this.m_reportObject = null; // We are changing the frame content.  The report object will be freed automatically.
    reportFrame.location.replace(url);
}
RSClientController.prototype.PerformClientSidePageChange = PerformClientSidePageChange;

function CommonReportPageQueryParams()
{
    var zoomValue = this.CurrentZoom();
    var zoomMode = "Percent";
    var zoomPercent = "100";        
    if (zoomValue == "PageWidth" || zoomValue == "FullPage")
        zoomMode = zoomValue;
    else
        zoomPercent = zoomValue;
        
    return "&ZoomMode=" + encodeURIComponent(zoomMode) + "&ZoomPct=" + encodeURIComponent(zoomPercent);
}
RSClientController.prototype.CommonReportPageQueryParams = CommonReportPageQueryParams;

function RSCC_LoadPrintControl()
{
    var printFrame = document.getElementById(this.m_printFrameId);
    if (printFrame != null)
    {
        if (printFrame.src != this.m_printHtmlLink)
            window.frames[this.m_printFrameId].window.location.replace(this.m_printHtmlLink);
        else
            eval(this.m_printFrameId + ".Print();");
    }
    
    return false;
}
RSClientController.prototype.LoadPrintControl = RSCC_LoadPrintControl;

function RSCC_SetPromptAreaVisibility(makeVisible)
{
    var parametersRow = document.getElementById(this.m_promptAreaRowId);
    if (parametersRow == null)
        return;
    var promptVisibilityState = document.getElementById(this.m_promptVisibilityStateId);

    if (makeVisible)
    {
        parametersRow.style.display = "";
        promptVisibilityState.value = "false";
    }
    else
    {
        parametersRow.style.display = "none";
        promptVisibilityState.value = "true";
    }

    this.CustomOnPromptAreaVisibilityChange();
}
RSClientController.prototype.SetPromptAreaVisibility = RSCC_SetPromptAreaVisibility;

function RSCC_ArePromptsVisible()
{
    var promptVisibilityState = document.getElementById(this.m_promptVisibilityStateId);
    return promptVisibilityState.value == "false";
}
RSClientController.prototype.ArePromptsVisible = RSCC_ArePromptsVisible;



// Link class constructor
function ReportViewerLink(linkID, initialActive, activeLinkStyle, disabledLinkStyle, activeLinkColor,
    disabledLinkColor, activeHoverLinkColor)
{
    this.m_linkID = linkID;
    this.m_isActive = initialActive;
    this.m_activeLinkStyle = activeLinkStyle;
    this.m_disabledLinkStyle = disabledLinkStyle;
    this.m_activeLinkColor = activeLinkColor;
    this.m_disabledLinkColor = disabledLinkColor;
    this.m_activeHoverLinkColor = activeHoverLinkColor;
    
    if (this.m_activeLinkStyle != "")
        this.m_isUsingStyles = true;
    else
        this.m_isUsingStyles = false;
}

function ReportViewerLinkIsViewerLinkActive()
{
    return this.m_isActive;
}
ReportViewerLink.prototype.IsViewerLinkActive = ReportViewerLinkIsViewerLinkActive;

function ReportViewerLinkSetViewerLinkActive(isActive)
{
    var button = GetControl(this.m_linkID);
    if (button == null)
        return;
        
    this.m_isActive = isActive;
    
    // If using styles, update style name
    if (this.m_isUsingStyles)
    {
        if (this.m_isActive)
            button.className = this.m_activeLinkStyle;
        else
            button.className = this.m_disabledLinkStyle;
    }
    
    this.OnLinkNormal();
}
ReportViewerLink.prototype.SetViewerLinkActive = ReportViewerLinkSetViewerLinkActive;

function ReportViewerLinkOnLinkHover()
{
    if (this.m_isUsingStyles)
        return;
        
    var link = GetControl(this.m_linkID);
    if (link == null)
        return;

    if (this.m_isActive)
    {
        link.style.textDecoration = "underline";
        link.style.color = this.m_activeHoverLinkColor;
        link.style.cursor = "pointer";
    }
    else
        link.style.cursor = "default";
}
ReportViewerLink.prototype.OnLinkHover = ReportViewerLinkOnLinkHover;

function ReportViewerLinkOnLinkNormal()
{
    if (this.m_isUsingStyles)
        return;

    var link = GetControl(this.m_linkID);
    if (link == null)
        return;

    if (this.m_isActive)
        link.style.color = this.m_activeLinkColor;
    else
        link.style.color = this.m_disabledLinkColor;
    link.style.textDecoration = "none";
}
ReportViewerLink.prototype.OnLinkNormal = ReportViewerLinkOnLinkNormal;







function ReportViewerHoverButton(buttonID, isPressed, normalStyle, hoverStyle, hoverPressedStyle, normalColor,
    hoverColor, hoverPressedColor, normalBorder, hoverBorder, hoverPressedBorder)
{
    this.m_buttonID = buttonID;
    this.m_isPressed = isPressed;
    this.m_normalStyle = normalStyle;
    this.m_hoverStyle = hoverStyle;
    this.m_hoverPressedStyle = hoverPressedStyle;
    this.m_normalColor = normalColor;
    this.m_hoverColor = hoverColor;
    this.m_hoverPressedColor = hoverPressedColor;
    this.m_normalBorder = normalBorder;
    this.m_hoverBorder = hoverBorder;
    this.m_hoverPressedBorder = hoverPressedBorder;

    if (this.m_normalStyle != "")
        this.m_isUsingStyles = true;
    else
        this.m_isUsingStyles = false;
}

function ReportViewerHoverButtonOnHover()
{
    var button = GetControl(this.m_buttonID);
    if (button == null)
        return;

    if (this.m_isUsingStyles)
        button.className = this.m_isPressed ? this.m_hoverPressedStyle : this.m_hoverStyle;
    else
    {
        button.style.border = this.m_isPressed ? this.m_hoverPressedBorder : this.m_hoverBorder;
        button.style.backgroundColor = this.m_isPressed ? this.m_hoverPressedColor : this.m_hoverColor;
        button.style.cursor = "pointer";
    }
}
ReportViewerHoverButton.prototype.OnHover = ReportViewerHoverButtonOnHover;

function ReportViewerHoverButtonOnNormal()
{
    var button = GetControl(this.m_buttonID);
    if (button == null)
        return;

    if (this.m_isUsingStyles)
        button.className = this.m_isPressed ? this.m_hoverStyle : this.m_normalStyle;
    else
    {
        button.style.border = this.m_isPressed ? this.m_hoverBorder : this.m_normalBorder;
        button.style.backgroundColor = this.m_isPressed ? this.m_hoverColor : this.m_normalColor;
        button.style.cursor = "default";
    }
}
ReportViewerHoverButton.prototype.OnNormal = ReportViewerHoverButtonOnNormal;

function ReportViewerHoverButtonSetPressed(isPressed)
{
    this.m_isPressed = isPressed;
    this.OnNormal();
}
ReportViewerHoverButton.prototype.SetPressed = ReportViewerHoverButtonSetPressed;







function RVTB_SetHasDocMap(docMapGroupId)
{
    var docMapGroup = document.getElementById(docMapGroupId);
    if (docMapGroup != null)
    {
        // Make the button visible
        docMapGroup.style.display = "inline";
        
        // Make sure there is a spacer (there won't be in the docmap is the only button), and make it visible
        var docMapSpacer = docMapGroup.nextSibling;
        if (docMapSpacer != null && docMapSpacer.ToolbarSpacer == "true")
            docMapSpacer.style.display = "inline";
    }
}