Home Page Icon
Home Page
Table of Contents for
III. Scripting in a Report Design
Close
III. Scripting in a Report Design
by Iana Chatalbasheva, Jane Tatchell, Tom Bondur, Don French, Jason Weathers
Integrating and Extending BIRT
Copyright
Foreward
Preface
About this book
Who Should Read This Book
Contents of This Book
Part I, Installing and Deploying BIRT
Part II, Understanding the BIRT Framework
Part III, Scripting in a Report Design
Part IV, Integrating BIRT Functionality into Applications
Part V, Working with the Extension Framework
Typographical Conventions
Syntax Conventions
Acknowledgments
I. Installing and Deploying BIRT
1. Prerequisites for BIRT
Requirements for the BIRT report designers
About installing required software
BIRT RCP Report Designer software requirements
BIRT Report Designer Full Eclipse Install software requirements
BIRT Report Designer software requirements
Prerequisites for other BIRT packages
BIRT Chart Engine software requirements
BIRT Demo Database software requirements
BIRT Report Engine software requirements
BIRT Samples software requirements
BIRT Test Suite software requirements
About types of BIRT builds
2. Installing a BIRT Report Designer
Installing BIRT Report Designer
Downloading and installing BIRT Report Designer
Installing the auxiliary file for BIRT Report Designer
Testing the BIRT Report Designer installation
Installing BIRT Report Designer Full Eclipse Install
Downloading and installing BIRT Report Designer Full Eclipse Install
Installing the auxiliary file for BIRT Report Designer
Installing BIRT RCP Report Designer
Downloading and installing BIRT RCP Report Designer
Installing the auxiliary file for BIRT Report Designer
Testing the BIRT RCP Report Designer installation
Troubleshooting installation problems
Avoiding cache conflicts after you install a BIRT report designer
Specifying which Java Virtual Machine to use when you start a BIRT report designer
Installing a language pack
3. Installing Other BIRT Packages
Installing BIRT Chart Engine
Installing BIRT Chart Engine from the Eclipse BIRT web site
Avoiding cache conflicts after installing
Installing BIRT Demo Database
Installing BIRT Demo Database from the Eclipse BIRT web site
Testing the BIRT Demo Database installation
Installing BIRT Report Engine
Installing BIRT Report Engine from the Eclipse BIRT web site
Testing the BIRT Report Engine installation
Installing BIRT Samples
Installing BIRT Test Suite
4. Updating a BIRT Installation
Using the Eclipse Update Manager to update BIRT Report Designer installation
Updating BIRT RCP Report Designer installation
5. Deploying a BIRT Report to an Application Server
About application servers
About deploying to Tomcat
About deploying to other application servers
Placing the BIRT report viewer on an application server
Installing the BIRT report viewer files
Installing the auxiliary file
Installing your JDBC drivers
Testing the BIRT report viewer installation
Using a different context root for the BIRT report viewer
Placing the viewer in a different location
Mapping the folders that the BIRT report viewer uses
Verifying that Apache Tomcat is running BIRT report viewer
Placing fonts on the application server
Viewing a report using a browser
Understanding the run and frameset servlets
Using the URL parameters for the run and frameset servlets
__report parameter
__document parameter
__format parameter
__locale parameter
__isnull parameter
__svg parameter
Report parameters
II. Understanding the BIRT Framework
6. Understanding the BIRT Architecture
Understanding the BIRT integration
About the BIRT applications
About BIRT Report Designer and BIRT RCP Report Designer
About the BIRT report viewer
About the BIRT engines
About the report design engine
About the report engine
About the generation engine
About the presentation engine
About the chart engine
About the data engine
About data engine components
About the ODA framework
About the types of BIRT report items
About standard report items
About custom report items
About chart report items
About the ROM
About the types of BIRT files
About report design files
About report document files
About report library files
About report template files
About custom Java applications
About custom report designers
About custom Java report generators
About extensions to BIRT
7. Understanding the Report Object Model
About the ROM specification
ROM properties
ROM slots
ROM methods
ROM styles
About the ROM schema
About the rom.def file
About the primary ROM elements
About the report item elements
About the report items
Understanding the report item element properties
About the data elements
III. Scripting in a Report Design
8. Using Scripting in a Report Design
Overview of BIRT scripting
Choosing between Java and JavaScript
Using both Java and JavaScript to write event handlers
Understanding the event handler execution sequence
About event firing sequence dependency
About the onCreate and onRender firing sequence dependencies
About the ReportDesign firing sequence dependencies
About the pageBreak event
Analysis of the execution sequence phases
Overview of the report execution process
Preparation phase
Report body processing phase
Clean-up processing phase
Row execution sequence
Table and list method execution sequence
Table and list setup phase
Table and list processing phase
Table and list wrap-up phase
Ungrouped table or list detail execution sequence
Grouped table or list execution sequence
About a report item event handler
About data source and data set event handlers
ODA data source events
Scripted data source events
ODA data set events
Scripted data set events
About ReportDesign event handlers
Writing event handlers for charts
Chart events
Chart script context
Chart instance object
Chart instance getter methods
Chart instance setter methods
Writing a Java chart event handler
Writing a JavaScript chart event handler
Getting a dynamic image from a Microsoft Access database
9. Using JavaScript to Write an Event Handler
Using BIRT Report Designer to enter a JavaScript event handler
Creating and using a global variable
Understanding execution phases and processes
Using the reportContext object
Passing a variable between processes
Getting information from an HTTP request object
Using the this object
Using the this object’s methods
Using the this object to set the property of a report item
Using the row object
Getting column information
Getting and altering the query string
Getting a parameter value
Changing the connection properties of a data source
Determining method execution sequence
Providing the ReportDesign.initialize code
Providing the code for the methods you want to track
Providing the ReportDesign.afterFactory code
Tutorial 1: Writing an event handler in JavaScript
Task 1: Open the report design
Task 2: Create and initialize a counter in the Table.onCreate( ) method
Task 3: Conditionally increment the counter in the Row.onCreate( ) method
Task 4: Display the result, using the ReportDesign.afterFactory( ) method
Calling Java from JavaScript
Understanding the Packages object
Understanding the importPackage method
Using a Java class
Placing your Java classes where BIRT can find them
Issues with using Java in JavaScript code
10. Using Java to Write an Event Handler
Writing a Java event handler class
Locating the JAR files that an event handler requires
Extending an adapter class
Making the Java class visible to BIRT
Associating the Java event handler class with a report element
BIRT Java interface and class naming conventions
Naming convention for event handler interfaces
Naming convention for event handler adapter classes
Naming convention for ROM element instance interfaces
Naming convention for ROM element design interfaces
Writing a Java event handler
Using event handler adapter classes
Using event handler interfaces
About the Java event handlers for report items
Using Java event handlers for the DataSource element
Using Java event handlers for the DataSet element
Using Java event handlers for the ScriptedDataSource element
Using Java event handlers for the ScriptedDataSet element
Using Java event handlers for the ReportDesign
Understanding the BIRT interfaces
About the element design interfaces
About the methods for each report element
About the IReportElement interface
About the element instance interfaces
Using the IReportContext interface
Using the IColumnMetaData interface
Using the IDataSetInstance interface
Using the IDataSetRow interface
Using the IRowData interface
11. Using a Scripted Data Source
Creating a scripted data source and scripted data set
Tutorial 2: Creating and scripting a scripted data source
Task 1: Create a new report
Task 2: Create a scripted data source
Task 3: Create a scripted data set
Task 4: Supply code for the open( ) and close( ) methods of the data source
Task 5: Supply code for the open( ) method of the data set
Task 6: Define output columns
Task 7: Place the columns on the report layout
Task 8: Supply code for the data set fetch( ) method
Using a Java object to access a data source
Performing initialization in the data set open( ) method
Getting a new row of data in the data set fetch( ) method
Cleaning up in the data set close( ) method
Deciding where to locate your Java class
Deploying your Java class
Using input and output parameters with a scripted data set
IV. Integrating BIRT Functionality into Applications
12. Understanding the BIRT APIs
Package hierarchy diagrams
About the BIRT Report Engine API
Creating the BIRT Report Engine
Using the BIRT Report Engine API
EngineConfig class
ReportEngine class
IReportRunnable interface
IReportDocument interface
IEngineTask interface
IGetParameterDefinitionTask interface
IDataExtractionTask interface
IRunTask interface
IRenderTask interface
IRunAndRenderTask interface
Report engine class hierarchy
Report engine interface hierarchy
About the design engine API
Using the BIRT design engine API
DesignEngine class
SessionHandle class
ModuleHandle class
ReportDesignHandle class
LibraryHandle class
DesignElementHandle class
Individual element handle classes
Design engine class hierarchy
ReportElementHandle hierarchy
ReportItemHandle hierarchy
ElementDetailHandle hierarchy
StructureHandle hierarchy
About the BIRT Chart Engine API
Using the BIRT Chart Engine API
Chart engine class hierarchy
chart.aggregate hierarchy
chart.datafeed hierarchy
chart.device class hierarchy
chart.device interface hierarchy
chart.event class hierarchy
chart.exception class hierarchy
chart.factory class hierarchy
chart.log class hierarchy
chart.model class hierarchy
chart.model.attribute interface hierarchy
chart.model.attribute class hierarchy
chart.model.component interface hierarchy
chart.model.data interface hierarchy
chart.model.layout interface hierarchy
chart.model.type interface hierarchy
chart.render hierarchy
chart.script hierarchy
chart.util class hierarchy
13. Programming with the BIRT Reporting APIs
Building a reporting application
Creating and configuring a report engine
Opening a report design or report document
Ensuring access to the data source
Preparing to create a report in the supported output formats
Generating a report in one of the supported output formats
Shutting down the engine
Optional tasks
About the environment for a reporting application
About plug-ins used by the report engine
About libraries used by the report engine
About required JDBC drivers
Modifying a report design with the API
Generating reports from an application
Setting up the report engine
Configuring the engine home
Configuring the report engine
Setting up a stand-alone or WAR file environment
Setting up the platform context
Setting up the HTML emitter
Using the logging environment to debug an application
How to use BIRT logging
Opening a source for report generation
Understanding an IReportRunnable object
How to access a report design
Understanding an IReportDocument object
Accessing a report parameter programmatically
Creating a parameter definition task object for the report design
Testing whether a report design has report parameters
Getting the report parameters in a report design
Getting the default value of each report parameter
Getting valid values for parameters using a restricted set of values
Getting the attributes of each report parameter
Collecting an updated value for each report parameter
How to set the value of a known report parameter
How to use the Collection of report parameters
Getting the values for cascading parameters
How to use cascading parameters
Preparing to generate the report
Setting the parameter values for running a report design
Setting up the rendering options
Setting up the rendering context
Setting up the HTML rendering context
Setting up the PDF rendering context
How to configure properties for a report in HTML format
Providing an external connection to run a report design
Generating the formatted output programmatically
Accessing the formatted report
About programming with a report design
About BIRT model API capabilities
Opening a report design programmatically for editing
Configuring the design engine to access a design handle
Using an IReportRunnable object to access a design handle
Using a report item in a report design
Accessing a report item by name
Accessing a report item by iterating through a slot
Examining a report item programmatically
Accessing the properties of a report item
Modifying a report item in a report design programmatically
Accessing and setting complex properties
Using a property handle
Using styles on a report item
Adding a report item to a report design programmatically
Accessing a data source and data set with the API
About data source classes
About data set classes
Using a data set programmatically
Changing the properties of a data set
Changing the data set binding of a report item
Saving a report design programmatically
Creating a report design programmatically
14. Programming with the BIRT Charting APIs
About the environment for building a charting application
Verifying the development environment for charting applications
Using the charting API to modify an existing chart
Getting a Chart object from the report design
Modifying chart properties
Modifying axes properties
Modifying plot properties
Modifying the legend properties
Modifying the series properties
Adding a series to a chart
Adding a chart event handler to a charting application
Adding a Java chart event handler to a charting application
Adding a JavaScript chart event handler to a charting application
Using the charting APIs to create a new chart
Creating the chart instance object
Setting the properties of the chart instance object
Setting the chart color and bounds
Setting plot properties
Setting legend properties
Setting legend line properties
Setting axes properties
Creating a category series
Creating a y-series
Defining the y-series queries
Setting the y-series properties
Setting the properties of the x- and y-series
Adding a series definition to the Axis object
Adding series, queries, and categories to the series definitions
Creating sample data
Getting an element factory object
Getting an extended item handle object
Setting the chart.instance property on the report item
Getting a data set from the report design
Binding the chart to the data set
Adding the new chart to the report design
Saving the report design after adding the chart
Putting it all together
Using the BIRT charting API in a Java Swing application
Understanding the chart programming examples
DataCharts
GroupOnXSeries
GroupOnYAxis
AutoDataBinding
FormatCharts
InteractivityCharts
PDFChartGenerator
StyleProcessor
ScriptViewer
Viewer
ChartWizardLauncher
Report
Preference
V. Working with the Extension Framework
15. Building the BIRT Project
About building the BIRT project
Assuring that you have the correct software on your system
Configuring the Eclipse workspace to compile BIRT
Creating Eclipse projects
Specifying the repository locations
Checking out the BIRT source
Adding the extra JAR file
Building the web viewer
16. Extending BIRT
Overview of the extension framework
Understanding the structure of a BIRT plug-in
Understanding an extension point schema definition file
Understanding a plug-in manifest file
Understanding a plug-in run-time class
Working with the Eclipse PDE
Understanding plug-in project properties
Understanding the Eclipse PDE Workbench
Creating the structure of a plug-in extension
Creating the plug-in extension content
Building a plug-in extension
Generating an Ant build script
Testing a plug-in extension
Deploying the extension plug-in
Installing feature updates and managing the Eclipse configuration
Creating an update site project
Downloading the code for the extension examples
17. Developing a Report Item Extension
Understanding a report item extension
Developing the sample report item extension
Downloading BIRT source code from the CVS repository
Creating a rotated label report item plug-in project
Defining the dependencies for the rotated label report item extension
Specifying the run-time package for the rotated label report item extension
Declaring the report item extension points
Creating the plug-in extension content
Understanding the rotated label report item extension
Understanding RotatedLabelItemFactoryImpl
Understanding RotatedLabelUI
Understanding RotatedLabelPresentationImpl
Understanding RotatedLabelReportItemImpl
Understanding RotatedLabelPropertyEditUIImpl
Understanding GraphicsUtil
Deploying and testing the rotated label report item plug-in
Deploying a report item extension
Launching the rotated label report item plug-in
18. Developing a Report Rendering Extension
Understanding a report rendering extension
Developing the CSV report rendering extension
Downloading BIRT source code from the CVS repository
Creating a CSV report rendering plug-in project
Defining the dependencies for the CSV report rendering extension
Declaring the emitters extension point
Understanding the sample CSV report rendering extension
Implementing the emitter interfaces
Implementing the content interfaces
Understanding the CSV report rendering extension package
Understanding CSVReportEmitter
Understanding the other CSVReportEmitter methods
Understanding CSVTags
Understanding CSVWriter
Understanding the BIRT report engine API package
Understanding RenderOptionBase
Understanding CSVRenderOption
Understanding EngineConstants
Testing the CSV report rendering plug-in
Launching the CSV report rendering plug-in
About ExecuteReport class
About the report design XML code
19. Developing an ODA Extension
Understanding an ODA extension
Developing the CSV ODA driver extensions
About the CSV ODA plug-ins
Downloading BIRT source code from the CVS repository
Implementing the CSV ODA driver plug-in
Defining the dependencies for the CSV ODA driver extension
Specifying the run-time settings for the CSV ODA driver extension
Declaring the ODA data source extension point
Understanding the sample CSV ODA driver extension
Implementing the DTP ODA interfaces
Understanding the CSV ODA extension package
Understanding CSVFileDriver
Understanding CSVFileQuery
Understanding ResultSet
Understanding ResultSetMetaData
Understanding DataSetMetaData
Understanding Messages
Understanding DataTypes
Understanding CommonConstant
Developing the CSV ODA UI extension
Creating the CSV ODA UI plug-in project
Defining the dependencies for the CSV ODA UI extension
Specifying the run-time settings for the CSV ODA UI extension
Declaring the ODA data source UI extension point
Understanding the sample CSV ODA UI extension
Implementing the ODA data source and data set wizards
Understanding the org.eclipse.birt.report.data.oda.csv.ui.wizards package
Understanding Constants
Understanding CSVFilePropertyPage
Understanding CSVFileSelectionPageHelper
Understanding CSVFileSelectionWizardPage
Understanding FileSelectionWizardPage
Testing the CSV ODA UI plug-in
Developing a Hibernate ODA extension
Creating the Hibernate ODA driver plug-in project
Understanding the sample Hibernate ODA driver extension
Understanding HibernateDriver
Understanding Connection
Understanding DataSetMetaData
Understanding Statement
Understanding ResultSet
Understanding HibernateUtil
Building the Hibernate ODA driver plug-in
Developing the Hibernate ODA UI extension
Understanding the sample Hibernate ODA UI extension
Understanding HibernatePageHelper
Understanding HibernateDataSourceWizard
Understanding HibernatePropertyPage
Understanding HibernateHqlSelectionPage
Building the Hibernate ODA UI plug-in
Testing the Hibernate ODA UI plug-in
Glossary
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
7. Understanding the Report Object Model
Next
Next Chapter
8. Using Scripting in a Report Design
Part III. Scripting in a Report Design
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset