IV. Integrating BIRT Functionality into Applications
by Iana Chatalbasheva, Jane Tatchell, Tom Bondur, Don French, Jason Weathers
Integrating and Extending BIRT
- Copyright
- Foreward
- Preface
- Acknowledgments
- I. Installing and Deploying BIRT
- 1. Prerequisites for BIRT
- 2. Installing a BIRT Report Designer
- 3. Installing Other BIRT Packages
- 4. Updating a BIRT Installation
- 5. Deploying a BIRT Report to an Application Server
- About application servers
- Placing the BIRT report viewer on an application server
- 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
- 7. Understanding the Report Object Model
- III. Scripting in a Report Design
- 8. Using Scripting in a Report Design
- Overview of BIRT scripting
- Understanding the event handler execution sequence
- About a report item event handler
- About data source and data set event handlers
- About ReportDesign event handlers
- Writing event handlers for charts
- 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
- Using the reportContext object
- Using the this object
- 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
- Tutorial 1: Writing an event handler in JavaScript
- Calling Java from JavaScript
- 10. Using Java to Write an Event Handler
- Writing a Java event handler 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
- 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
- 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
- Using input and output parameters with a scripted data set
- 8. Using Scripting in a Report Design
- IV. Integrating BIRT Functionality into Applications
- 12. Understanding the BIRT APIs
- Package hierarchy diagrams
- About the BIRT Report Engine API
- About the design engine API
- 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
- Modifying a report design with the API
- Generating reports from an application
- Setting up the report engine
- Opening a source for report generation
- 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
- Getting the values for cascading parameters
- Preparing to generate the report
- 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
- 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
- Adding a report item to a report design programmatically
- Accessing a data source and data set with the API
- Saving a report design programmatically
- Creating a report design programmatically
- Building a reporting application
- 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
- 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
- 12. Understanding the BIRT APIs
- V. Working with the Extension Framework
- 15. Building the BIRT Project
- 16. Extending BIRT
- Overview of the extension framework
- Understanding the structure of a BIRT plug-in
- Working with the Eclipse PDE
- Creating the structure of a plug-in extension
- Creating the plug-in extension content
- Building a plug-in extension
- Deploying the extension plug-in
- 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
- Deploying and testing the rotated label report item plug-in
- 18. Developing a Report Rendering Extension
- Understanding a report rendering extension
- Developing the CSV report rendering extension
- Understanding the sample CSV report rendering extension
- Testing the CSV report rendering plug-in
- 19. Developing an ODA Extension
- Understanding an ODA extension
- Developing the CSV ODA driver extensions
- Implementing the CSV ODA driver plug-in
- Understanding the sample CSV ODA driver extension
- Developing the CSV ODA UI extension
- Understanding the sample CSV ODA UI extension
- 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
- Building the Hibernate ODA driver plug-in
- Developing the Hibernate ODA UI extension
- Understanding the sample Hibernate ODA UI extension
- Building the Hibernate ODA UI plug-in
- Testing the Hibernate ODA UI plug-in
- Glossary
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.