Contents
Part 1 Installing and Deploying BIRT
Chapter 1 Introducing BIRT Report Designers
Understanding Eclipse BIRT packages
Chapter 2 Installing a BIRT Report Designer
Installing BIRT Report Designer Full Eclipse Install
Installing BIRT RCP Report Designer
Troubleshooting installation problems
Avoiding cache conflicts after you install a BIRT report designer
Specifying a Java Virtual Machine when starting BIRT report designer
Updating a BIRT Report Designer installation
Updating BIRT RCP Report Designer installation
Chapter 3 Installing Other BIRT Packages
Installing BIRT Data Tools Platform Integration
Installing BIRT Web Tools Integration
Chapter 4 Deploying a BIRT Report to an Application Server
About deploying to other application servers
Placing the BIRT report viewer on an application server
Installing the BIRT report viewer as a web application
Testing the BIRT report viewer installation
Changing the BIRT report viewer context root
Changing the BIRT report viewer location
Understanding the BIRT report viewer context parameters
Verifying that Apache Tomcat is running BIRT report viewer
Placing fonts on the application server
Viewing a report using a browser
Using connection pooling on Tomcat
Setting up a report to use connection pooling
Configuring a JNDI connection object on Tomcat
Part 2 Understanding the BIRT Framework
Chapter 5 Understanding the BIRT Architecture
Understanding the BIRT integration
About BIRT Report Designer and BIRT RCP Report Designer
About the BIRT engines and services
About the presentation services
About the data engine and services
About the types of BIRT report items
About the Report Object Model (ROM)
About custom Java applications
About a custom report designer
About a custom Java report generator
Chapter 6 Understanding the Report Object Model
About the primary ROM elements
Understanding report item element properties
Part 3 Scripting in a Report Design
Chapter 7 Using Scripting in a Report Design
Choosing between JavaScript and Java
Using both JavaScript and Java
Types of data source and data set events
About data source and data set events
About table and list event order
Completion of the generation phase
Chapter 8 Using JavaScript to Write an Event Handler
Using BIRT Report Designer to enter a JavaScript event handler
Creating and using a global variable
Creating and using page variables and scripts
Understanding execution phases and processes
Using the reportContext object
Using reportContext to retrieve the report design handle
Passing a variable between processes
Getting information from an HTTP request object
Using the this object to set a report item property
Getting and altering the query string
Changing data source connection properties
Determining script execution sequence
Providing the ReportDesign.initialize code
Providing code for the scripts you want to track
Providing the ReportDesign.afterFactory code
Tutorial 1: Writing an event handler in JavaScript
Task 1: Create the report design
Task 2: Create a counter in Table.onCreate
Task 3: Conditionally increment the counter
JavaScript event handler examples
Calling external JavaScript functions
Understanding the Packages object
Understanding the importPackage method
Issues with using Java in JavaScript code
Calling the method of a class in a plug-in
Chapter 9 Using Java to Write an Event Handler
Writing a Java event handler class
Locating the JAR files for a BIRT event handler
Making the Java class visible to BIRT
Associating a Java event handler class with a report element
BIRT Java interface and class naming conventions
Using event handler adapter classes
Using event handler interfaces
About the Java event handlers for report items
Using Java event handlers for a data source element
Using Java event handlers for a data set element
Using Java event handlers for a scripted data source element
Using Java event handlers for a scripted data set element
Using Java event handlers for a report design
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
Debugging a Java event handler
Chapter 10 Working with Chart Event Handlers
Understanding the Chart script context
Accessing the Chart instance in an event handler
Understanding the external context
Understanding when chart events fire
About the beforeDataSetFilled event
About the afterDataSetFilled event
About the beforeGeneration event
About the afterGeneration event
Rendering data points and data point labels
Writing a Java chart event handler
Setting up the chart event handler project
Java chart event handler examples
Writing a JavaScript chart event handler
Using the simplified charting API
Getting an instance of a chart item
Understanding the sub-interfaces of IChart
Chapter 11 Using Scripting to Access Data
Tutorial 2: Creating a scripted data source
Task 1: Create a new report design
Task 2: Create a scripted data source
Task 3: Create a scripted data set
Task 4: Write the open( ) and close( ) methods of the data source
Task 5: Write the open( ) method of the data set
Task 6: Write the fetch( ) method of the data set
Task 7: Place the columns on the report layout
Writing the scripted data set in Java
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 place your Java class
Using input and output parameters with a scripted data set
Creating a web services data source using a custom connection class
Chapter 12 Debugging Event Handlers
Checking the syntax of JavaScript expressions
Debugging JavaScript event handlers code
Debugging Java event handler code
Debugging report execution exceptions
Creating a debug configuration
Tutorial 3: Debugging a report that contains Java and JavaScript code
Task 1: Preparing the report for debugging
Task 2: Setting a JavaScript breakpoint
Task 3: Setting a Java breakpoint
Task 4: Create the debug configuration
Part 4 Integrating BIRT into Applications
Chapter 13 Understanding the BIRT APIs
About the BIRT Report Engine API
Creating the BIRT ReportEngine instance
Using the BIRT Report Engine API
IGetParameterDefinitionTask interface
Report engine interface hierarchy
Using the BIRT Design Engine API
Individual element handle classes
Design engine interface hierarchy
About the BIRT Chart Engine API
Using the BIRT Chart Engine API
chart.aggregate class and interface hierarchy
chart.datafeed class and interface hierarchy
chart.device class and interface hierarchy
chart.event class and interface hierarchy
chart.exception class hierarchy
chart.factory class and interface hierarchy
chart.log class and interface hierarchy
chart.model interface hierarchy
chart.model.attribute class and interface hierarchy
chart.model.component interface hierarchy
chart.model.data interface hierarchy
chart.model.layout interface hierarchy
chart.model.type interface hierarchy
chart.render class and interface hierarchy
chart.script class and interface hierarchy
Chapter 14 Programming Using the BIRT Reporting APIs
Building a reporting application
About the development environment
Setting up the build path and accessing Javadoc
Modifying a report design using the API
About the deployment environment
Generating reports from an application
Setting up a stand-alone or WAR file environment
Using the logging environment to debug an application
Opening a source for report generation
Understanding an IReportRunnable object
Understanding an IReportDocument object
Preparing to generate the report
Setting the parameter values for running a report design
Adding to the report engine’s class path
Providing an external object to a report design
Generating a binary report document
Preparing to render a formatted report
Setting up the rendering options
Accessing the formatted report
Checking the status of a running report task
Cancelling a running report task
Programming the structure of a report design
About BIRT model API capabilities
Opening a report design 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 iterating through a slot
Accessing a report item by name
Accessing the properties of a report item
Modifying a report item in a report design
Accessing and setting complex properties
Understanding property structure objects
Adding a report item to a report design
Accessing a data source and data set with the API
Using a data set programmatically
Chapter 15 Programming Using the BIRT Charting API
About the chart engine contents
About the environment for a charting application
Configuring the chart engine run-time environment
Verifying the environment for a charting application
About the charting API and the chart structure
Using the charting API to create a new chart
Understanding simple and complex properties
Associating data with a series
Adding a series definition to a chart
Setting up the default aggregation for the chart
Changing the aggregation for secondary value series
Adding a Java chart event handler
Adding a JavaScript chart event handler
Using a chart item in a report design
Accessing an existing chart item
Getting a design engine element factory object
Setting the chart type and subtype
Getting an extended item handle object
Setting up the report item as a chart
Preparing a data set and data columns
Binding the chart to the data set
Set any other report item properties
Adding the new chart to the report design
Saving the report design after adding the chart
Using the BIRT charting API in a Java Swing application
Understanding the chart programming examples
SwingChartViewerSelector example
SWTChartViewerSelector example
Part 5 Working with the Extension Framework
Chapter 16 Building the BIRT Project
About building the BIRT project
Installing a working version of BIRT
Configuring Eclipse to compile BIRT and build the viewer JAR files
Downloading and extracting the correct version of the BIRT source code
Importing, building, and testing the BIRT project
Building new JAR files to display BIRT output
Building the viewservlets.jar file
Building the chart-viewer.jar file
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
Understanding plug-in project properties
Understanding the Eclipse PDE Workbench
Creating the structure of a plug-in extension
Creating the plug-in extension content
Generating an Ant build script
Deploying the extension plug-in
Creating an update site project
Downloading the code for the extension examples
Chapter 18 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 RotatedLabelPresentationImpl
Understanding RotatedLabelCategoryProviderFactory
Understanding RotatedLabelGeneralPage
Deploying and testing the rotated label report item plug-in
Deploying a report item extension
Launching the rotated label report item plug-in
Developing an advanced report item
Defining the report item model
Defining the report item UI design
Defining the report item presentation
Improving the report item UI design
Creating a report item builder
Binding the report item to data
Changes in the model definition
Changes in the report item presentation
Changing the report item UI to support expressions
Adding data binding to the builder
Adding data binding to the property page
Chapter 19 Developing a Report Rendering Extension
Understanding a report rendering extension
Developing a CSV report rendering extension
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
Understanding the CSV report rendering extension package
Understanding CSVReportEmitter
Testing the CSV report rendering plug-in
About the report design XML code
Developing an XML report rendering extension
Creating an XML report rendering plug-in project
Defining the dependencies for the XML report rendering extension
Declaring the emitters extension point
Understanding the sample XML report rendering extension
Understanding the XML report rendering extension package
Understanding XMLReportEmitter
Understanding LoadExportSchema
Testing the XML report rendering plug-in
Chapter 20 Developing an ODA Extension
Understanding an ODA extension
Developing the CSV ODA driver extensions
Downloading BIRT source code from the CVS repository
Implementing the CSV ODA driver plug-in
Understanding the ODA data source extension points
Understanding dataSource extension point properties
Understanding ConnectionProfile properties
Understanding the dependencies for the CSV ODA driver extension
Understanding the sample CSV ODA driver extension
Understanding ResultSetMetaData
Developing the CSV ODA user interface extension
Creating the CSV ODA user interface plug-in project
Understanding the ODA data source user interface extension points
Understanding the ConnectionProfile extension point
Understanding the propertyPages extension point
Understanding the dataSource extension point
Understanding the sample CSV ODA user interface extension
Implementing the ODA data source and data set wizards
Understanding the org.eclipse.birt.report.data.oda.csv.ui.impl package
Understanding the org.eclipse.birt.report.data.oda.csv.ui.wizards package
Understanding CSVFilePropertyPage
Understanding CSVFileSelectionPageHelper
Understanding CSVFileSelectionWizardPage
Understanding FileSelectionWizardPage
Testing the CSV ODA user interface plug-in
Developing a Hibernate ODA extension
Creating the Hibernate ODA driver plug-in project
Understanding the sample Hibernate ODA driver extension
Building the Hibernate ODA driver plug-in
Developing the Hibernate ODA user interface extension
Understanding the sample Hibernate ODA user interface extension
Understanding HibernatePageHelper
Understanding HibernateDataSourceWizard
Understanding HibernatePropertyPage
Understanding HibernateHqlSelectionPage
Building the Hibernate ODA user interface plug-in
Testing the Hibernate ODA user interface plug-in
Chapter 21 Developing a Data Extraction Extension
Understanding a data extraction extension
Developing an XML data extraction extension
Creating an XML data extraction plug-in project
Defining the dependencies for the XML data extraction extension
Declaring the data extraction extension point
Understanding the XML data extraction extension
Implementing the data extraction interfaces
Understanding the XML document format
Understanding XMLDataExtractionImpl methods
Testing the XML data extraction plug-in
About the report design XML code
Chapter 22 Developing a Fragment
Developing the sample fragment
Understanding the sample fragment
Building, deploying, and testing a fragment
Chapter 23 Developing a Charting Extension
About BIRT charting extension points
Setting up the build environment
Implementing the extension points
Design-time plug-in extensions
Chart UI-types extension point
Series composite extension point
Chart model types extension point
Data processor extension point