Classes


Class actuate.Viewer

Retrieves and displays Actuate BIRT report contents in an HTML container. The actuate.Viewer class displays the report by page. The goto functions of this class change the current position and page displayed in the viewer.
Member of: actuate.

Class Summary
Constructor Attributes Constructor Name and Description
 
actuate.Viewer(container, uiConfig)
Constructs a report viewer.
Method Summary
Method Attributes Method Name and Description
 
Removes the viewer from the cache and cleans the html.
 
disableIV(callback)
Disable the interactive viewing features.
 
downloadReport(format, pages, renderoption)
Exports the report with a specified format.
 
downloadResultSet(request, callback)
Gets all the data from the report as specified by the request.
 
enableIV(callback)
Enables interactive viewing features for this Viewer, which enables the selection and modification of report content.
 
getChart(bookmark)
Returns a report chart by bookmark.
 
Gets the browser window's height.
 
Gets the browser window's width.
 
getContentByBookmark(bookmark, format, callback)
Gets the report content by bookmark and passes the content as data to the callback.
 
getContentByPageRange(pageRange, format, callback)
Gets the report content by Page Range and passes the content as data to a callback.
 
Gets the viewer content margin.
 
Returns the report content displayed in the viewer.
 
Returns the page number for the page currently being displayed.
 
getCustomViz(bookmark)
Returns a new customViz object referenced by a bookmark.
 
getDataItem(bookmark)
Returns report data referenced by a bookmark.
 
getFlashObject(bookmark)
Returns a Flash object referenced by a bookmark.
 
getGadget(bookmark)
Returns a gadget referenced by a bookmark.
 
Returns the height value of the viewer.
 
getLabel(bookmark)
Returns a label referenced by a bookmark.
 
Returns the bookmark of the current report page or element.
 
Returns the name of the report file, either a report design file or report document file, that is currently displayed in this Viewer.
 
getTable(bookmark)
Returns the table referenced by a bookmark.
 
getText(bookmark)
Returns a Text object referenced by a bookmark.
 
Returns the total number of pages in the report being viewed.
 
Returns the current UI configuration.
 
Returns the actuate.viewer.UIOptions set in this Viewer object.
<static>  
getViewer(elementId)
Returns a Viewer object containing the report element that is associated with a bookmark or that an HTML element contains.
 
Returns the width value of the viewer.
 
gotoBookmark(bookmark)
Goes to the page position by the specified bookmark.
 
gotoPage(pageNum)
Goes to the specified page.
 
Returns the interactive viewing status of the viewer.
 
saveReportDesign(fileName, callback)
Saves the current viewer content as a report design.
 
saveReportDocument(fileName, callback)
Saves the current viewer content as a report document.
 
setBRSEnabled(setBRSEnabled)
Set whether Report Studio is enabled.
 
Sets the viewer content margin.
 
setFocus(focus)
Sets viewer focus.
 
setGadgetId(dashboard, dashboard)
Set dashboard gadget id and dashboard design name.
 
setHeight(height)
Sets the viewer height.
 
setParameters(params)
Sets parameters for executing report using literal string pairs.
 
Sets parameter values for executing a report using actuate.parameter.ParameterValue objects.
 
setReportDocument(reportDocument, connectionHandle)
Sets the report document and connection handle
 
Sets the bookmark for the Reportlet rendered.
 
setReportName(reportFile)
Sets the report file, either a report design or report document, to render in this Viewer.
 
setService(iportalUrl, requestOptions)
Sets the target service URL to which this viewer links.
 
setSize(width, height)
Resizes the viewer's width and height.
 
setSupportSVG(svgFlag)
Controls Scalable Vector Graphics support for the viewer.
 
setUIOptions(options)
Sets the UI options for the viewer using an actuate.viewer.UIOptions object.
 
setWidth(width)
Sets the viewer width.
 
Displays the export report dialog window.
 
Displays the export data dialog window.
 
Displays the Facebook Comment panel.
 
Displays the parameter panel.
 
Displays the print dialog.
 
Displays the Table of Contents panel.
 
submit(callback, rerun)
Updates and reloads the viewer after submitting requests for the viewer.
Class Detail
actuate.Viewer(container, uiConfig)
Constructs a report viewer. For example, to assign the viewer to display in a <div id='containerName' /> tag on the page, use the following constructor call:
	var myViewer = new actuate.Viewer("containerName");
Parameters:
{String | Object} container
A document object or string that references the <div> element in which to display the viewer.
{actuate.viewer.UIConfig} uiConfig
optional User Intefrace configuration object
Method Detail
{void} cleanup()
Removes the viewer from the cache and cleans the html.
Returns:
{void}

{void} disableIV(callback)
Disable the interactive viewing features. This is an asynchronous operation, the callback will be called once the operation is finished.

It must be used in the callback of actuate.Viewer#submit as shown the following example:

    function runStandard(){
        myViewer.setReportName("/Public/BIRT and BIRT Studio Examples/Crosstab Sample Revenue.rptdocument");
        myViewer.submit(function() {myViewer.disableIV(function alertUser( ){alert("IV disabled");});});
    }
Parameters:
{Function} callback
callback to be called once the operation is finished. The callback takes the following arguments:
Returns:
{void}
See:
actuate.Viewer#submit

{void} downloadReport(format, pages, renderoption)
Exports the report with a specified format. The downloadReport function does not return any object. The report is exported to the client side. Then the browser opens a download window for the user to specify a location for the report. To download the first five pages of the report in the viewer, use the following code:
	myViewer.downloadReport("pdf", "1-5", null);
Parameters:
{String} format
The format in which to export the report. Valid values and their corresponding formats are:
  • afp: IBM Advanced Function Printing
  • doc: Word
  • docx: Word 2007
  • html: HTML-encoded web page
  • ppt: PowerPoint
  • pptx: PowerPoint 2007
  • pdf: Adobe PDF
  • ps: PostScript
  • xls: Excel
  • xlsx: Excel 2007
{String} pages
The pages to retrieve. Indicate page ranges by using the first page number of the range and the last page number separated by a dash. To use more than one value, separate individual page numbers or page ranges with commas.
{actuate.viewer.RenderOptions} renderoption
Optional. Sets the rendering options for the download, which currently only applies to multisheet xls format reports.
Throws:
{actuate.viewer.ViewerException}
if the format argument is missing or if the page range is invalid.
Returns:
{void}

{void} downloadResultSet(request, callback)
Gets all the data from the report as specified by the request. This function makes an AJAX call to the server for the data that is not in the current page. Write a callback function to process the result set. The callback must take an actuate.data.ResultSet object as an argument. This example creates an actuate.data.ResultSet object from the report in myViewer as specified by myRequest and passes it to a callback function:
	myViewer.downloadResultSet(myRequest, callback);
Parameters:
{actuate.data.Request} request
The request to generate the result set.
{Function} callback
The callback function to call after retrieving the results. The callback function must take an actuate.data.ResultSet object as an argument.
Throws:
{actuate.viewer.ViewerException}
if an invalid argument is passed
Returns:
{void}
See:
actuate.DataService#downloadResultSet

{void} enableIV(callback)
Enables interactive viewing features for this Viewer, which enables the selection and modification of report content.

This function must be used in the callback of actuate.Viewer#submit as shown the following example:

    function runInteractive(){
        myViewer.setReportName("/Public/BIRT and BIRT Studio Examples/Sales by Customer.rptdesign");
        myViewer.submit(function() {myViewer.enableIV(callback);});
    }
Parameters:
{Function} callback
The callback function to call after enabling the Interactive Viewer features. The callback must take a actuate.Viewer input argument, which is the current viewer.
Returns:
{void}
See:
actuate.Viewer#submit

{actuate.report.Chart} getChart(bookmark)
Returns a report chart by bookmark. This example returns the chart with the bookmark ChartBookmark:
	function getMyChartByBookmark(myReport) {
		var myViewer = myReport.getViewer("Chart");
		var bpagecontents = myViewer.getCurrentPageContent( );
		return bpagecontents.getChart("ChartBookmark");
	}
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.Chart} chart

{integer} getClientHeight()
Gets the browser window's height. To reset the viewer height to 20 pixels less than the browser window if it is larger than the browser window, use code similar to the following:
	if(myViewer.getClientHeight( ) < myViewer.getHeight( )){
		myViewer.setHeight(myViewer.getClientHeight( ) - 20);
	}
Returns:
{integer} Height in pixels.

{integer} getClientWidth()
Gets the browser window's width. To reset the viewer width to 20 pixels less than the browser window if it is larger than the browser window, use code similar to the following:
	if(myViewer.getClientWidth( ) < myViewer.getWidth( )){
		myViewer.setWidth(myViewer.getClientWidth( ) - 20);
	}
Returns:
{integer} Width in pixels.

{void} getContentByBookmark(bookmark, format, callback)
Gets the report content by bookmark and passes the content as data to the callback. To retrieve the content with the bookmark FirstChart as html, use code similar to the following:
	myViewer.getContentByBookmark("FirstChart", "html", processChart);
Parameters:
{String} bookmark
The bookmark of a report element to retrieve.
{String} format
The output format, which is either html or xhtml.
{Function} callback
Callback to be called once the operation is finished. The callback must take actuate.data.ReportContent object as an argument.
Returns:
{void}

{void} getContentByPageRange(pageRange, format, callback)
Gets the report content by Page Range and passes the content as data to a callback. To retrieve the content from pages 3 through 5 as html, use code similar to the following:
	myViewer.getContentByPageRange("3-5", "html", processPages);
Parameters:
{String} pageRange
Page range to retrieve the report content, separated by a dash.
{String} format
The output format, which is either html or xhtml.
{Function} callback
Callback to be called once the operation is finished. The callback must take actuate.data.ReportContent object as an argument.
Returns:
{void}

{Integer | Object} getContentMargin()
Gets the viewer content margin. To set the margin of the viewer newViewer to match the margin of myViewer, use code similar to the following:
	newViewer.setContentMargin(myViewer.getContentMargin( ));
Returns:
{Integer | Object} An integer indicates the same margin on all sides, in pixels. The object contains the pixel values for the top, bottom, left, and right margins of the viewer in an array. For example, a 25-pixel top content margin and no margin in the other directions would be the object array {top:25, left:0, right:0, bottom:0}.

{actuate.viewer.PageContent} getCurrentPageContent()
Returns the report content displayed in the viewer. This function is the entry point for retrieving the report elements from this Viewer object. Use this function to access the bookmarks for specific elements in the page content. For example, to access the table "mytable" on the page loaded in the myViewer Viewer object, use the following code:
	var element = myViewer.getCurrentPageContent( ).getTableByBookmark("mytable");
Returns:
{actuate.viewer.PageContent} PageContent object

{integer} getCurrentPageNum()
Returns the page number for the page currently being displayed. This function is useful to move to another page relative to the current page. To go to the next page in a document, use the following code:
	myViewer.gotoPage(viewer.getCurrentPageNum( ) + 1);
Returns:
{integer} The current page number.

{actuate.report.CustomViz} getCustomViz(bookmark)
Returns a new customViz object referenced by a bookmark. To get the new customViz object with the bookmark Title and store it in the variable customViz, use code similar to the following:
	var customViz = myViewer.getCustomViz("bookmark");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.CustomViz} customViz object

{actuate.report.DataItem} getDataItem(bookmark)
Returns report data referenced by a bookmark. To get the report data with the bookmark FirstDataItem and store it in the variable myDataItem, use code similar to the following:
	var myDataItem = myViewer.getDataItem("FirstDataItem");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.DataItem} data item

{actuate.report.FlashObject} getFlashObject(bookmark)
Returns a Flash object referenced by a bookmark. To get the Flash object with the bookmark FirstFlashObject and store it in the variable myFlashObject, use code similar to the following:
	var myFlashObject = myViewer.getFlashObject("FirstFlashObject");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.FlashObject} The flash object

{actuate.report.Gadget} getGadget(bookmark)
Returns a gadget referenced by a bookmark. To get the gadget with the bookmark FirstGadget and store it in the variable myGadget, use code similar to the following:
	var myGadget = myViewer.getGadget("FirstGadget");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.Gadget} The gadget object.

{String} getHeight()
Returns the height value of the viewer. This example decreases the viewer's height by 10:
	var height = myViewer.getHeight( );
	myViewer.setHeight(height - 10);
Returns:
{String} Height in pixels.

{actuate.report.Label} getLabel(bookmark)
Returns a label referenced by a bookmark. To get the label with the bookmark FirstLabel and store it in the variable myLabel, use code similar to the following:
	var myLabel = myViewer.getLabel("FirstLabel");
																	
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.Label}

{String} getReportletBookmark()
Returns the bookmark of the current report page or element. This example displays the bookmark of the current report page in an alert box:
	alert ("Report bookmark is " + myViewer.getReportletBookmark( ));
Returns:
{String} The reportlet bookmark for the current report page or element.

{String} getReportName()
Returns the name of the report file, either a report design file or report document file, that is currently displayed in this Viewer. This example displays the currently displayed report file name in an alert box:
	alert ("Currently displaying " + myViewer.getReportName( ));
Returns:
{String} report file name

{actuate.report.Table} getTable(bookmark)
Returns the table referenced by a bookmark. To get the table with the bookmark FirstTable and store it in the variable myTable, use code similar to the following:
	var myTable = myViewer.getTable("FirstTable");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.Table} table

{actuate.report.TextItem} getText(bookmark)
Returns a Text object referenced by a bookmark. To get the Text object with the bookmark Title and store it in the variable myText, use code similar to the following:
	var myText = myViewer.getText("Title");
Parameters:
{String} bookmark
The bookmark name.
Returns:
{actuate.report.TextItem} text item

{integer} getTotalPageCount()
Returns the total number of pages in the report being viewed. This function is useful to move to the last page of a document. To go to the last page in a document, use the following code:
	myViewer.gotoPage(viewer.getTotalPageCount( ));
Returns:
{integer} The total number of pages.

{actuate.viewer.UIConfig} getUIConfig()
Returns the current UI configuration. To retrieve and store the content pane from the viewer, use the following code:
	var contentpane = viewer.getUIConfig( ).getContentPane( );
Returns:
{actuate.viewer.UIConfig} UIConfig This function returns null when no UIConfig object is set.

{actuate.viewer.UIOptions} getUIOptions()
Returns the actuate.viewer.UIOptions set in this Viewer object. To retrieve and store the actuate.viewer.UIOptions for the viewer, use the following code:
	var options = myViewer.getUIOptions( );
Returns:
{actuate.viewer.UIOptions} UI options object. This function returns null when no actuate.viewer.UIOptions object is set.

<static> {actuate.Viewer} getViewer(elementId)
Returns a Viewer object containing the report element that is associated with a bookmark or that an HTML element contains. This example uses getViewer( ) to retrieve a report element and return the bookmark of the chart in that report:
	function chartBookmark(myReport){
		var myViewer = myReport.getViewer("Chart");
		var bpagecontents = myViewer.getCurrentPageContent( );
		return bpagecontents.getChartByBookmark("ChartBookmark");
	}
Parameters:
{String | Object} elementId
The bookmark of the report element to view or an HTML element object.
Returns:
{actuate.Viewer} object or null if viewer is not found.

{String} getWidth()
Returns the width value of the viewer. This example decreases the viewer's width by 10:
	var width = myViewer.getWidth( );
	myViewer.setWidth(width - 10);
Returns:
{String} The width in pixels.

{void} gotoBookmark(bookmark)
Goes to the page position by the specified bookmark. The viewer displays to the first page when the bookmark is not found. To move the viewer to the page position specified by the value of the 'bookmark' parameter, use this code:
	myViewer.gotoBookmark(document.getElementById('bookmark').value);
If the page changes, the viewer fires a CONTENT_CHANGED event.
Parameters:
{String} bookmark
The bookmark of a report element.
Returns:
{void}
See:
actuate.viewer.EventConstants.ON_CONTENT_CHANGED

{void} gotoPage(pageNum)
Goes to the specified page. The viewer throws an exception when the page is not found. To go to the first page of a report, use the following code:
	myViewer.gotoPage(1);
Once the page has switched, the viewere fires a CONTENT_CHANGED event.
Parameters:
{integer} pageNum
A page number in the report, starting at 1.
Throws:
{actuate.viewer.ViewerException}
if an invalid page number is passed
Returns:
{void}
See:
actuate.viewer.EventConstants.ON_CONTENT_CHANGED

{boolean} isInteractive()
Returns the interactive viewing status of the viewer. Enables or disables the interactive viewing features with actuate.Viewer#enableIV. This example displays an alert box with the interactive status of the viewer:
	alert("Interactivity of this viewer is set to " + myViewer.isInteractive( ));
Returns:
{boolean} true if the viewer is in interactive mode, false otherwise

{void} saveReportDesign(fileName, callback)
Saves the current viewer content as a report design. The viewer must enable interactive viewing with actuate.Viewer#enableIV prior to saving a report design. To save the content of the viewer as the report design called NewDesign, use the following code:
	myViewer.saveReportDesign("NewDesign");
Parameters:
{String} fileName
Sets the name of the saved file. The current file name is used if null. The file name must be a path relative to the viewer's repository.
{Function} callback
Optional. The function to execute after the asynchronous call processing is done. The callback takes the current {@lnik actuate.Viewer} object as an input parameter.
Returns:
{void}

{void} saveReportDocument(fileName, callback)
Saves the current viewer content as a report document. The viewer must enable interactive viewing with actuate.Viewer#enableIV prior to saving a report design. To save the content of the viewer as the report document called NewDocument, use the following code:
	myViewer.saveReportDocument("NewDocument");
Parameters:
{String} fileName
Sets the name of the saved file. The current file name is used if null. The file name must be a path relative to the viewer's repository.
{Function} callback
Optional. The function to execute after the asynchronous call processing is done. The callback takes the current {@lnk actuate.Viewer} object as an input parameter.
Returns:
{void}

setBRSEnabled(setBRSEnabled)
Set whether Report Studio is enabled.
Parameters:
setBRSEnabled

{void} setContentMargin(margin)
Sets the viewer content margin. To set the internal margin of the viewer to a 10-pixel buffer, use the following code:
	myViewer.setContentMargin(10);
Parameters:
{String[] | integer} margin
Each member of the array is the margin for the top, left, right, and bottom internal margins for the viewer. An integer sets all margins to that value.
Returns:
{void}

{void} setFocus(focus)
Sets viewer focus. This example blurs the context menu for the viewer:
	myViewer.setFocus(false);
Parameters:
{boolean} focus
The viewer's context menu is in focus when this parameter is set to true.
Returns:
{void}

{void} setGadgetId(dashboard, dashboard)
Set dashboard gadget id and dashboard design name. Need design name to persistent the operation.
Parameters:
{String} dashboard
design name
{String} dashboard
gadget id
Returns:
{void}

{void} setHeight(height)
Sets the viewer height. To set the height of the viewer to 600 pixels, use the following code:
	myViewer.setHeight(600);
Parameters:
{integer} height
The height in pixels.
Returns:
{void}

{void} setParameters(params)
Sets parameters for executing report using literal string pairs. To set the value of a parameter, city, to the value, New York, use the following object literal:
	myViewer.setParameters({ city:"New York"});
Parameters:
{String[]} params
Array of strings. Each string in the array is constructed of name:"value" pairs. Use a literal list, such as {param1:"value1", param2:"value2", ... }.
Returns:
{void}

{void} setParameterValues(params)
Sets parameter values for executing a report using actuate.parameter.ParameterValue objects. To set the parameter values for a report to the parameters in the pvs array, use the following code:
	myViewer.setParameterValues(pvs);
Parameters:
{actuate.Parameter.ParameterValue[]} params
Array of actuate.parameter.ParameterValue objects. An array of this kind is returned by actuate.Parameter#downloadParameterValues and is the recommended function for creating the parameters input.
Returns:
{void}

setReportDocument(reportDocument, connectionHandle)
Sets the report document and connection handle
Parameters:
{String} reportDocument
report document file name
{String} connectionHandle
connection handle (optional). connectionHandle is needed for transient document such as below sample.
		var transientDoc = '/$$$Transient/1.RPTDOCUMENT';
		var connectionHandle = 'bAq%2by9HJrv6%2bASENxVq8RL21WvOI%2fw6jmbZwg7PYF19Cq3057d%2bJTeUKSSPpu8CJEdtWledo6r5Fb4yX4Ucvyt84%2f3qNdvlyhsrKW4Ea9pqM5kAaOG0yYC4aPy2mpHna2DvON58eYK9UFLLwuiIIjA12d%2bA6VRbqDUEh4QXsTxDX9ote2naiNdq8z7y1oAAx2wtbdi%2b6KSCTQeG5TUZNAJCkoE1hMX9gyXXRgxg%2bA4EYN77EWXbNIEqEHJjhzEpMQGjSVa0%2bPCrogQ4qBhGaPA%3d%3d';
		myViewer.setReportDocument( transientDoc, connectionHandle  );
Throws:
{actuate.viewer.ViewerException}
if an unknown file type is passed

{void} setReportletBookmark(bookmark)
Sets the bookmark for the Reportlet rendered. To open the Top 5 Customers Reportlet of the Customer Dashboard, set the Reportlet bookmark by name and then call actuate.Viewer#submit, as shown in the following example:
	myViewer.setReportName("/Public/BIRT and BIRT Studio Examples/Customer Dashboard.rptdocument");
	myViewer.setReportletBookmark("Top 5 Customers");
	myViewer.submit( );
Parameters:
{String} bookmark
The bookmark ID used to render the Reportlet. Viewer requires a bookmark to render a Reportlet. Viewer does not support automatically generated generic bookmarks from a BIRT report.
Returns:
{void}

{void} setReportName(reportFile)
Sets the report file, either a report design or report document, to render in this Viewer. To open the Top 5 Sales Performers report, set the report by name and then call actuate.Viewer#submit, as shown in the following example:
	myViewer.setReportName("/Public/BIRT and BIRT Studio Examples/Top 5 Sales Performers.rptdesign");
	myViewer.submit( );
Parameters:
{String} reportFile
The report file path for a report design file or report document file. To set the version for the report, add a semicolon and the version number. For example, "/Public/BIRT and BIRT Studio Examples/Customer Dashboard.rptdesign;1" retrieves version 1 of Customer Dashboard.rptdesign.
Throws:
{actuate.viewer.ViewerException}
if an unknown file type is passed
Returns:
{void}

{void} setService(iportalUrl, requestOptions)
Sets the target service URL to which this viewer links. When the service URL is not set, this Viewer links to the default service URL, which is set on the actuate object. This example sets the URL for the Actuate iPortal web application service:
	myViewer.setService("http://localhost:8700/iportal", myRequestOptions);
Parameters:
{String} iportalUrl
The target Actuate web application URL, either a Java Component or Information Console.
{actuate.RequestOptions} requestOptions
Optional. RequestOptions defines URL parameters to send with the authentication request, such as the iServer URL, Encyclopedia volume, or repository type. The URL can also include custom parameters.
Returns:
{void}

{void} setSize(width, height)
Resizes the viewer's width and height. To set the viewer's size to 300 pixels by 300 pixels, use code similar to the following:
	myViewer.setSize(300, 300);
Parameters:
{integer} width
The new width is specified in pixels.
{integer} height
he new height is specified in pixels.
Returns:
{void}

{void} setSupportSVG(svgFlag)
Controls Scalable Vector Graphics support for the viewer. To disable Scalable Vector Graphic support for the myViewer viewer, use code similar to the following:
	myViewer.setSupportSVG(false);
Parameters:
{boolean} svgFlag
True enables Scalable Vector Graphic support
Returns:
{void}

{void} setUIOptions(options)
Sets the UI options for the viewer using an actuate.viewer.UIOptions object. To hide the toolbar for the viewer, use the following code:
	uioptions.enableToolBar(false);
	viewer.setUIOptions(uioptions);
	viewer.submit( );
Parameters:
{actuate.viewer.UIOptions} options
Enables or disables various controls and features.
Returns:
{void}

{void} setWidth(width)
Sets the viewer width. To set the width of the viewer to 800 pixels, use the following code:
	viewer.setWidth(800);
Parameters:
{integer} width
Returns:
{void}

{void} showDownloadReportDialog()
Displays the export report dialog window. Use this code to display the report dialog window:
	myViewer.showDownloadReportDialog( );
Returns:
{void}

{void} showDownloadResultSetDialog()
Displays the export data dialog window.
Returns:
{void}

{void} showFacebookCommentPanel()
Displays the Facebook Comment panel.
Returns:
{void}

{void} showParameterPanel()
Displays the parameter panel.
Returns:
{void}

{void} showPrintDialog()
Displays the print dialog.
Returns:
{void}

{void} showTocPanel()
Displays the Table of Contents panel.
Returns:
{void}

{void} submit(callback, rerun)
Updates and reloads the viewer after submitting requests for the viewer. The submit function triggers an AJAX request for all asynchronous operations. When the server finishes the processing, it returns a response and the results are rendered on the page in the viewer container. Calling actuate.Viewer#submit when a previous actuate.Viewer#submit is pending throws an exception. To open the Top 5 Sales Performers report, set the report by name and then call submit, as shown in the following example:
	viewer.setReportName("/Public/BIRT and BIRT Studio Examples/Top 5 Sales Performers.rptdesign");
	viewer.submit( );
If the viewer content is changed, the viewer fires a CONTENT_CHANGED event.
Parameters:
{Function} callback
Optional. The function to execute after the asynchronous call processing is done. The callback receives an actuate.Viewer object as an input parameter.
{Boolean} rerun
Indicates whether to re-run the report design when refreshing. Default to true.
Returns:
{void}
See:
actuate.viewer.EventConstants.ON_CONTENT_CHANGED

Documentation generated by JsDoc Toolkit 2.0.1 on Tue Jan 06 2015 04:13:44 GMT-0800 (PST)