Reporting Advertising

     

What Pentaho Reporting can do for you

Current Stable

Previous

In Development

Pentaho Reporting allows you to refine your raw data into visually appealing reports that convey all the information you need to make better decisions and to get your job done faster. The open architecture of the reporting system and our Open-Source nature makes it a breeze to integrate the reporting engine into your existing systems.

Many of the worlds leading enterprises already use our technology to gain a competitive edge. What are you waiting for? Download it now!

Learn more about Pentaho Reporting

Pentaho Reporting 3.8.3

Pentaho Reporting 3.8.2

Pentaho Reporting 4.0.0

Development for this version has just started. Relax, it will take a while. Crosstabs are coming ..

Saturday, July 24, 2010

Java: the holy language of God

After years and years of studying various holy sources I am finally able to present my research results. Looking at the Qur'an (yes, Ministry of Homeland Security, I'm one of them apparently), the Popol Vuh, the Bhagavad-Gita and even a page or two of the Bible clearly proves that God (or Gods, as with omnipresent omniscient entities you can never be sure with whom you are talking right now) speaks Java (and not more than Java Language Specification 1.2).

Every reader of the aforementioned books first notices the convoluted and verbose use of syntactical elements. Every reader of Java source code first notices the convoluted and verbose use of syntactical elements. Of course, this is good, as it gives you time to think while reading the text, without overloading your mind with to many facts in to little time. Linguists found that redundancy in a language improves its error resistance and its understandability.

Along with that, there is a lack of shorthand constructs and cryptic sequences of unspeakable characters. Gods language is clean and simple so that every creature can hear it without getting knots in their brain. It is notable that some print media uses text known from lesser languages like *(x+=y++%8) to signal profanity.

The products and rules of God expressed in the holy books apply to the whole universe. Most of the texts make explicit statements about this "write once, run everywhere" principle. The creator of the universe made his rules .. well .. universal. Being the omnipotent entity he is he could have created a universe where he has no power. But to avoid imploding the brains of those who study the universe he obviously refrained from creating that paradox.

Holy (and maybe not so holy) men (and woman, but less in numbers and usually burning rather quickly if being overly verbose) pointed out that one can find the answer to any of life's problems in those holy books, if you study the text long enough. Smart (and sometimes not so smart) men (and woman, but less in numbers but not burning these days due to worries about the CO2 footprint) pointed out that one can find the answer to any of the core programming problems in the fairly complete Java runtime library, if you study the JavaDoc long enough.


Sadly, even tho the Gods are Java and Java therefore is God, there is evidence that humans are probably created in C or C++.

The first thing you notice when you look at humans is their obvious need for manual resource management. Breathing is a classical example of allocating a resource (air) and freeing it after use (breathing out). There are numerous examples where failure of either allocation or release of the resource caused unrecoverable errors in the program execution.

Looking around the planet, it is also obvious that humans in general do not do a good job in freeing their resources properly. Garbage collection is virtually unknown even tho viable garbage collectors exist. The various resource allocation strategies and conflicts give cause to much grief and pain.

Looking at humans you can see a clear platform dependency. Although it is claimed that the same source or genetic code could be adapted to various environments, humans tend to die rather quickly (and sometimes in fairly interesting ways) if transplanted to a different runtime environment.

And last but not least: A freshly created human is void of any usable strategies and has to spend years and years to build up a reasonable runtime library (which then is over-adapted to the specific environment and fails easily when ported to a different platform (see the section on resource management above). Likewise the C languages themselves come with only the minimum standard library. Extra functionality has to be manually coded or brought in from outside. Humans call this process education, programmers "importing a library". Different educations/libraries usually come with complex and contradictory requirements causing more vendor dependence and thus again pain and grief.


So humans: abandon your erroneous ways, repent and join the forces of god and stick to 100% pure Java.

Wednesday, July 14, 2010

Charting the way YOU want it ..

How would you feel if you knew you could each of the million features of JFreeChart to work within the Pentaho Reporting System? After all, it is a ugly thing for a consultant or system developer to say "no, sorry, can't do that" to a customer or client. Especially when you have that shiny new JFreeChart Developer Guide on your desk telling you that there is a way.

Imagine a world without sentences like "Uh .. sure JFreeChart supports this feature, but it is not exposed in the Report Designer".

Well, with Pentaho Reporting 3.7 you can live in that world right now.

All chart expressions now have the "Chart Post-Processing Script Language" and "Chart Post-Processing Script" properties. The "Script Language" property defines the scripting language in which the actual script is written (so that the more masochistic ones among our users can continue to use JavaScript all day long) and the "Script" property itself then contains the script.

Like the well-known BeanShell- and BSH-Expressions, a set of predefined variables grants access to the outside world.

"chart" is the fully initialized JFreeChart object. "dataRow" grants access to the values of the other named expressions and the data-table "runtime" grants access to the current ExpressionRuntime instance. The runtime itself allows the use of the ResourceBundles (for internationalization) and grants access to the report's defined DataFactories (to get more data from the outside world).

A simple post processing script could look like this (Language = BeanShell):
import java.util.Date;

chart.setTitle("My Title: " + new Date());


But with the ability to fire queries, you can easily add your own line or item marker to explain significant details or enrich the plots with your own styling.

Your imagination (and coding abilities) are the limit now!

Friday, July 9, 2010

Drill-Down Update: Charting and Images now with ImageMap support

Our main focus for Pentaho Reporting 3.7 is locked on improving the user experience when adding links to reports. The DRILLDOWN function and its made-to-measure UI bring us a long way towards the holy grail of being 'easy to use'(tm).

Putting links on text is nice. But since Dashboards became the standard, everyone seems to want to click on hot areas in images and charts as well. In HTML, this problem is solved by providing a image-map. This structure holds the outline of the hot-spots as polygons (or circles or rectangles) along with the tooltip and hyperlink target.

I love to 'borrow' a good idea when I see it.

All content-elements now ship with a new attribute called "image-map", that allows you to provide a image-map for your images. The image-map must be a valid XML fragment, something like this:

<?xml version="1.0">
<map>
<area type="rect" coords="10,10,40,40" 
      href="http://www.google.com" title="A search engine"/>
</map>

Usually such a image-map will be computed at runtime by using an attribute-expression. But computing such maps manually is less fun than it sounds. So if no user-provided image-map is given, our Drawables can compute these maps on the fly as well.

All of our JFreeChart generator expressions now produce a JFreeChartReportDrawable objects instead of a plain JFreeChart objects. All ReportDrawables provide the "getImageMap(Rectangle2D)" method so that output targets that support image-maps can annotate their generated images with links and tooltips.

You can use the new "tooltip-formula" and "url-formula" properties on the chart-expressions to provide a formula for the tooltip and URL generators. Within the formula you have access to several automatically generated fields (in addition to all values of the regular fields at the time the chart is rendered).

Categorical-Charts:

  • "chart::series-key": The current series-value
  • "chart::category-key": The current category-value
  • "chart::series-index": The number of the series
  • "chart::category-index": The number of the category
  • "chart::series-keys": All known series-keys as array
  • "chart::category-keys": All known category-keys as array
  • "chart::value": The current value for the current series and category.

XY-Charts:

  • "chart::x-value": The current x-value
  • "chart::y-value": The current y-value
  • "chart::z-value": The current z-value
  • "chart::series-index": The number of the current series
  • "chart::series-count": The total number of series in the chart
  • "chart::item-index": The current item within the series
  • "chart::item-count": The total number of items within the series.

Pie-, Ring- and Multi-Pie Charts:

  • "chart::key": The current key for the pie-slice
  • "chart::keys": All known keys
  • "chart::item": The current item value for the pie-slice
  • "chart::items": All items
  • "chart::pie-index": The number of the current pie-chart (used in Multi-Pie charts)

At the moment, only the HTML export fully supports image maps. The PDF export already supports tooltips, but the links are not yet working. The work on the full image-map link support into PDF and to enable that stuff in the Swing preview as well should be finished next week.

And remember: The formula-properties of the chart-expressions can use the DRILLDOWN function to compute the links.