DynamicReports

https://dynamicreports.readthedocs.io/en/latest/
Admin
DynamicReports is a free and open-source Java library for creating dynamic report designs at runtime...
Tokens:10,319
Snippets:149
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Quick Usage Example

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportBands.html

A simple example demonstrating the basic structure of report bands.

```plaintext
1
2
3
4
```

--------------------------------

### Create Jasper Report Builder from Configuration

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportAdhoc.html

This example demonstrates converting an AdhocReport configuration into a JasperReportBuilder instance and setting its datasource.

```java
JasperReportBuilder reportBuilder = AdhocManager.createReport(configuration.getReport());
reportBuilder.setDatasource(...);
```

--------------------------------

### Basic Report Creation with JasperReportBuilder

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportBuilder.html

Demonstrates the quick usage of JasperReportBuilder to define columns, a title, and set a data source. This is a fundamental example for creating simple reports.

```java
report()
 .columns(
     col.column("Item", "item", type.stringType()),
     col.column("Quantity", "quantity", type.integerType()))
 .title(cmp.text("Report title"))
 .setDataSource(...)
 .show();
```

--------------------------------

### Java Syntax with Static Imports and Method Chaining

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Syntax.html

Illustrates how to use static imports and method chaining in DynamicReports for more concise and readable code. This example simplifies method calls by avoiding class name qualification.

```java
import static net.sf.dynamicreports.DynamicReports.*;
report()
 .columns(
     col.column("Item", "item", type.stringType()),
     col.column("Quantity", "quantity", type.integerType()))
 .title(cmp.text("Report title"))
 .setDataSource(dataSource)
 .show();
```

--------------------------------

### Using Default Font in Java

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Fonts.html

Renders a text component using the globally configured default font. This example shows how the default font is applied when no explicit style is set.

```java
report().
    title(cmp.text("text - default font"))
```

--------------------------------

### Complex Expression Example

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Expression.html

An example of a complex expression that registers additional fields ('quantity' and 'unitprice') before evaluation. It calculates the total price using the provided values and ReportParameters.

```java
private class ComplexExpression extends AbstractComplexExpression<BigDecimal> {
 public ComplexExpression() {
     addExpression(field("quantity", Integer.class));
     addExpression(field("unitprice", BigDecimal.class));
 }

 @Override
 public BigDecimal evaluate(List<?> values, ReportParameters reportParameters) {
     Integer quantity = (Integer) values.get(0);
     BigDecimal unitPrice = (BigDecimal) values.get(1);
     return new BigDecimal(quantity).multiply(unitPrice);
 }
 }
```

--------------------------------

### Simple Expression Example

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Expression.html

A basic implementation of a simple expression that calculates the total price by multiplying quantity and unit price. It requires a ReportParameters object to access field values.

```java
private class SimpleExpression extends AbstractSimpleExpression<BigDecimal> {
 public BigDecimal evaluate(ReportParameters reportParameters) {
     Integer quantity = reportParameters.getValue("quantity");
     BigDecimal unitPrice = reportParameters.getValue("unitprice");
     return new BigDecimal(quantity).multiply(unitPrice);
 }
 }
```

--------------------------------

### Implement Conditional Styles for Price

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Apply conditional styles to a price column to change its appearance based on its value. This example makes the price bold and sets background colors for prices greater than 200 (green) or smaller than 20 (red).

```java
ConditionalStyleBuilder condition3 = stl.conditionalStyle(cnd.greater(priceColumn, 200))
                                       .setBackgroundColor(new Color(0, 190, 0))
                                       .bold();
ConditionalStyleBuilder condition4 = stl.conditionalStyle(cnd.smaller(priceColumn, 20))
                                       .setBackgroundColor(new Color(190, 0, 0))
                                       .bold();
StyleBuilder priceStyle = stl.style()
                            .conditionalStyles(
                              condition3, condition4);

priceColumn = unitPriceColumn.multiply(quantityColumn).setTitle("Price")
                      .setDataType(currencyType)
                      .setStyle(priceStyle);
```

--------------------------------

### Default DynamicReports Configuration

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Configuration.html

This XML snippet shows the default configuration for DynamicReports. It includes commented-out examples for setting default fonts, defining custom patterns and alignments for various data types, and enabling system font loading.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<DynamicReports>
   <!-- DEFAULT FONT -->
   <!--
   <font fontName="SansSerif" fontSize="10"/>
   -->

   <!-- DEFAULT DATA TYPES -->
   <!--
   <bigDecimalType pattern="#,##0.00#" horizontalAlignment="RIGHT"/>
   <bigIntegerType pattern="#,##0" horizontalAlignment="RIGHT"/>
   <byteType pattern="#,##0" horizontalAlignment="RIGHT"/>
   <doubleType pattern="#,##0.#" horizontalAlignment="RIGHT"/>
   <floatType pattern="#,##0.#" horizontalAlignment="RIGHT"/>
   <integerType pattern="#,##0" horizontalAlignment="RIGHT"/>
   <longType pattern="#,##0" horizontalAlignment="RIGHT"/>
   <shortType pattern="#,##0" horizontalAlignment="RIGHT"/>
   <dateType pattern="MM/dd/yyyy" horizontalAlignment="RIGHT"/>
   <dateYearToMonthType pattern="MM/yyyy" horizontalAlignment="RIGHT"/>
   <dateYearToHourType pattern="MM/dd/yyyy h a" horizontalAlignment="RIGHT"/>
   <dateYearToMinuteType pattern="MM/dd/yyyy h:mm a" horizontalAlignment="RIGHT"/>
   <dateYearToSecondType pattern="MM/dd/yyyy h:mm:ss a" horizontalAlignment="RIGHT"/>
   <dateYearToFractionType pattern="MM/dd/yyyy h:mm:ss,SSS a" horizontalAlignment="RIGHT"/>
   <dateYearType pattern="yyyy" horizontalAlignment="RIGHT"/>
   <dateMonthType pattern="MMMM" horizontalAlignment="RIGHT"/>
   <dateDayType pattern="dd" horizontalAlignment="RIGHT"/>
   <timeHourToMinuteType pattern="h:mm a" horizontalAlignment="RIGHT"/>
   <timeHourToSecondType pattern="h:mm:ss a" horizontalAlignment="RIGHT"/>
   <timeHourToFractionType pattern="h:mm:ss,SSS a" horizontalAlignment="RIGHT"/>
   <percentageType pattern="#,##0.00%" horizontalAlignment="RIGHT"/>
   <booleanType horizontalAlignment="CENTER"/>
   <characterType horizontalAlignment="LEFT"/>
   <stringType horizontalAlignment="LEFT"/>
   -->

   <!-- LOAD SYSTEM FONTS -->
   <!--
   <loadSystemFonts>true</loadSystemFonts>
   -->
</DynamicReports>
```

--------------------------------

### Apply Detail Row Highlighters

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Highlight detail rows based on conditions using ConditionalStyleBuilder. This example sets background colors for rows where the price is greater than 150 (green) or smaller than 30 (red).

```java
ConditionalStyleBuilder condition1 = stl.conditionalStyle(cnd.greater(priceColumn, 150))
                                       .setBackgroundColor(new Color(210, 255, 210));
ConditionalStyleBuilder condition2 = stl.conditionalStyle(cnd.smaller(priceColumn, 30))
                                       .setBackgroundColor(new Color(255, 210, 210));
 .detailRowHighlighters(
 condition1, condition2)
```

--------------------------------

### Concatenating Reports with JasperConcatenatedBuilder

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportBuilder.html

Shows how to use JasperConcatenatedBuilder to combine two existing JasperReportBuilder instances into a single PDF document. Each report will start on a new page.

```java
JasperReportBuilder report1 = ...;
JasperReportBuilder report2 = ...;
concatenatedReport()
 .concatenate(report1, report2)
 .toPdf(...);
```

--------------------------------

### Create and Configure Adhoc Report

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportAdhoc.html

This snippet demonstrates how to create an AdhocConfiguration, add an AdhocReport, and define a column for the report.

```java
AdhocConfiguration configuration = new AdhocConfiguration();
AdhocReport report = new AdhocReport();
configuration.setReport(report);
AdhocColumn column = new AdhocColumn();
column.setName("item");
report.addColumn(column);
```

--------------------------------

### Load Adhoc Configuration from Stream

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportAdhoc.html

This snippet illustrates how to load an AdhocConfiguration from an input stream using AdhocManager.

```java
AdhocConfiguration configuration = AdhocManager.loadConfiguration(configuration, inputStream);
```

--------------------------------

### Classic Java Syntax for Report Building

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Syntax.html

Demonstrates the traditional Java syntax for creating a report using DynamicReports without static imports or method chaining. This approach requires explicit class name qualification for methods.

```java
JasperReportBuilder report = DynamicReports.report();
report.addColumn(Columns.column("Item", "item", DataTypes.stringType()));
report.addColumn(Columns.column("Quantity", "quantity", DataTypes.integerType()));
report.addTitle(Componens.text("Report title"));
report.setDataSource(dataSource)
report.show();
```

--------------------------------

### Set Database Data Source

Source: https://dynamicreports.readthedocs.io/en/latest/docs/DataSource.html

Quickly set a database as the data source for a report using a SQL query and a connection object. Ensure a properly configured database connector is available.

```java
java.sql.Connection connection = ...;
String query = "SELECT * FROM ...";
report()
  .setDataSource(query, connection)
```

--------------------------------

### Basic Report Structure

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Illustrates the fundamental structure of a DynamicReports report, including adding columns, groups, subtotals, setting a data source, and exporting to PDF or Excel. This serves as a high-level overview of the report building process.

```java
import static net.sf.dynamicreports.report.builder.DynamicReports.*;
public class Report {
   private void build() {
     try {
       report()//create new report design
         .columns(...) //adds columns
         .groupBy(...) //adds groups
         .subtotalsAtSummary(...) //adds subtotals
         ...
         //set datasource
         .setDataSource(...)
         //export report
         .toPdf(...) //export report to pdf
         .toXls(...) //export report to excel
         ...
         //other outputs
         .toJasperPrint() //creates jasperprint object
         .show() //shows report
         .print() //prints report
         ...
     } catch (DRException e) {
       e.printStackTrace();
     }
   }
   ...
 }
```

--------------------------------

### Report Band Configuration

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportBands.html

Configures title, page header, and page footer bands with text components.

```java
report()
 .title(cmp.text("This is a title band"))
 .pageHeader(cmp.text ("This is a page header band"))
 .pageFooter(cmp.text ("This is a page footer band"))
```

--------------------------------

### Apply Styles to Report Elements

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Demonstrates how to define and apply styles to report elements, including bold text, centered alignment, borders, and background colors. Styles can inherit properties from parent styles, and are applied to columns, titles, and footers.

```java
StyleBuilder boldStyle         = stl.style().bold();
StyleBuilder boldCenteredStyle = stl.style(boldStyle)
                                   .setHorizontalAlignment(HorizontalAlignment.CENTER);

StyleBuilder columnTitleStyle  = stl.style(boldCenteredStyle)
                                   .setBorder(stl.pen1Point())
                                   .setBackgroundColor(Color.LIGHT_GRAY);
report()
   .setColumnTitleStyle(columnTitleStyle)
   .highlightDetailEvenRows()
   .title(cmp.text("Getting started").setStyle(boldCenteredStyle))
   .pageFooter(cmp.pageXofY().setStyle(boldCenteredStyle))
```

--------------------------------

### Add Subtotals to Summary and Group Footer

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Use `sbt.sum(column)` to calculate subtotals. `subtotalsAtSummary` adds them to the summary band, while `subtotalsAtFirstGroupFooter` adds them to the first group's footer.

```java
.subtotalsAtSummary(
     sbt.sum(unitPriceColumn), sbt.sum(priceColumn))
.subtotalsAtFirstGroupFooter(
     sbt.sum(unitPriceColumn), sbt.sum(priceColumn))
```

--------------------------------

### Create a Bar 3D Chart by Item

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Builds a 3D bar chart using `cht.bar3DChart()`. Set the category and add series using `addSerie()`. The `setUseSeriesAsCategory(true)` option can be used to switch category and series.

```java
Bar3DChartBuilder itemChart = cht.bar3DChart()
                                .setTitle("<a href=\"https://web.archive.org/web/20180130194401/http://www.dynamicreports.org/examples/sales\" title=\"Sales\">Sales</a> by item")
                                .setCategory(itemColumn)
                                .addSerie(
                                   cht.serie(unitPriceColumn), cht.serie(priceColumn));
Bar3DChartBuilder itemChart2 = cht.bar3DChart()
                                .setTitle("<a href=\"https://web.archive.org/web/20180130194401/http://www.dynamicreports.org/examples/sales\" title=\"Sales\">Sales</a> by item")
                                .setCategory(itemColumn)
                                .setUseSeriesAsCategory(true)
                                .addSerie(
                                  cht.serie(unitPriceColumn), cht.serie(priceColumn))
```

--------------------------------

### Maven Snapshot Repository Configuration

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Configuration.html

Add this repository configuration to your pom.xml to enable Maven to download development snapshots of DynamicReports from the Sonatype Nexus repository.

```xml
<repositories>
  <repository>
    <id>sonatype-nexus-snapshots</id>
    <name>Sonatype Nexus Snapshots</name>
    <url>https://oss.sonatype.org/content/repositories/snapshots</url>
    <releases>
      <enabled>false</enabled>
    </releases>
    <snapshots>
      <enabled>true</enabled>
    </snapshots>
  </repository>
</repositories>
```

--------------------------------

### Save Adhoc Configuration to Stream

Source: https://dynamicreports.readthedocs.io/en/latest/docs/ReportAdhoc.html

This code snippet shows how to save an AdhocConfiguration object to an output stream using AdhocManager.

```java
AdhocManager.saveConfiguration(configuration, outputStream);
```

--------------------------------

### Jasper Expression for Price Calculation

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Expression.html

Demonstrates how to declare a Jasper native expression for calculating price using $F{quantity} and $F{unitprice}. It also shows how to create a Jasper expression for a static text title.

```java
JasperExpression<BigDecimal> columnExpression = exp.jasperSyntax("new BigDecimal($F{quantity}).multiply($F{unitprice})", BigDecimal.class);
JasperExpression<String> columnTitle = exp.jasperSyntaxText("Price");
TextColumnBuilder<BigDecimal> priceColumn = col.column(columnExpression).setTitle(columnTitle);
```

--------------------------------

### Set Data Source Object from Collection

Source: https://dynamicreports.readthedocs.io/en/latest/docs/DataSource.html

Quickly set a collection of Java objects as the data source for a report. This is useful for providing in-memory data to the report.

```java
List<JavaBean> data = new ArrayList<JavaBean>();
report()
  .setDataSource(new JRBeanCollectionDataSource(data))
```

--------------------------------

### Define Title Style

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Creates a custom style for report titles using `stl.style()`. This includes setting font size, alignment, and vertical alignment. It also demonstrates applying a top border to a filler component.

```java
StyleBuilder titleStyle = stl.style(boldCenteredStyle)
                            .setVerticalAlignment(VerticalAlignment.MIDDLE)
                            .setFontSize(15);
```

--------------------------------

### Add Charts to Report Summary

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Embeds pre-configured charts into the report's summary section using the `.summary()` method.

```java
.summary(itemChart, itemChart2)
```

--------------------------------

### Create Percentage Column

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Generate a percentage column using col.percentageColumn(). This can be based on existing column values or field values, and supports configuration for total types and groups.

```java
TextColumnBuilder<Integer> quantityColumn = col.column("Quantity", "quantity", type.integerType());
PercentageColumnBuilder quantityPercColumn = col.percentageColumn("Quantity [%]", quantityColumn);
report()
 .columns(
     quantityColumn, quantityPercColumn)
 .setDataSource(...)
```

--------------------------------

### DynamicReports Default Settings XML

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Configuration.html

This XML file defines default settings for DynamicReports, such as fonts and data type patterns. Copy this file to the root of your classpath to apply these defaults.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<DynamicReports>
  <!-- DEFAULT FONT -->
  <font fontName="SansSerif" fontSize="10" pdfFontName="Helvetica" pdfEncoding="Cp1252" pdfEmbedded="false"/>

  <!-- DEFAULT DATA TYPES -->
  <bigDecimalType pattern="#,##0.00#" horizontalAlignment="RIGHT"/>
  <dateType pattern="MM/dd/yyyy" horizontalAlignment="RIGHT"/>
...
</DynamicReports>
```

--------------------------------

### Registering Font Families in fonts.xml

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Fonts.html

Defines font families, including normal, bold, italic, and bold-italic styles, along with PDF encoding and embedding options. This XML file should be placed in the root of the classpath.

```xml
<fontFamilies>
    <fontFamily name="FreeUniversal">
        <normal>net/sf/dynamicreports/examples/fonts/FreeUniversal-regular.ttf</normal>
        <bold>net/sf/dynamicreports/examples/fonts/FreeUniversal-Bold.ttf</bold>
        <italic>net/sf/dynamicreports/examples/fonts/FreeUniversal-Italic.ttf</italic>
        <boldItalic>net/sf/dynamicreports/examples/fonts/FreeUniversal-BoldItalic.ttf</boldItalic>
        <pdfEncoding>Cp1252</pdfEncoding>
        <pdfEmbedded>true</pdfEmbedded>
    </fontFamily>
</fontFamilies>
```

--------------------------------

### Format BigDecimal with Currency

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Expression.html

This snippet demonstrates how to format a BigDecimal value by appending a currency symbol. It requires extending `AbstractValueFormatter` and implementing the `format` method.

```java
TextColumnBuilder<BigDecimal>  column = ...;
column.setValueFormatter(new ValueFormatter()))
private class ValueFormatter extends AbstractValueFormatter<String, BigDecimal> {
    public String format(BigDecimal value, ReportParameters reportParameters) {
        return value + " EUR";
    }
}
```

--------------------------------

### Set Report Title and Page Footer

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Configures the report's title and page footer. The title is set using DynamicReports.cmp.text, and the page number is displayed in the footer using DynamicReports.cmp.pageXofY. These methods allow customization of report bands.

```java
.title(cmp.text("Getting started"))//shows report title
.pageFooter(cmp.pageXofY())//shows number of page at page footer
```

--------------------------------

### Generate PDF Report in Servlet

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Servlets.html

This servlet generates a PDF report using DynamicReports and streams it to the web browser. Ensure the response content type is set to 'application/pdf'.

```java
import static net.sf.dynamicreports.report.builder.DynamicReports.*;
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.dynamicreports.report.exception.DRException;

public class PdfReportServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("application/pdf");
        OutputStream out = resp.getOutputStream();
        try {
        report()
            ...
            .toPdf(out);
        } catch (DRException e) {
        throw new ServletException(e);
        }
        out.close();
    }
}
```

--------------------------------

### Create Component Column

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Creates a new component column to display custom components like images or complex content. An optional title can be provided.

```java
ImageBuilder image = cmp.image(...);
 ComponentBuilder<?, ?> component = ...;
report()
 .columns(
     col.componentColumn("Image", image),
     col.componentColumn("Component", component))
 .setDataSource(...)
```

--------------------------------

### Arrange Components Horizontally with a Container

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Uses `cmp.horizontalList()` to arrange multiple components side-by-side within a report band. This is useful for creating layouts where components need to be placed horizontally.

```java
.summary(
   cmp.horizontalList(itemChart, itemChart2))
```

--------------------------------

### Create Report Title with Components

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Constructs a report title using `cmp.horizontalList()` to arrange an image, text, and another text component. A filler component with a top border is added below to create separation.

```java
.title(//shows report title
    cmp.horizontalList()
 .add(
   cmp.image(getClass().getResourceAsStream("../images/dynamicreports.png")).setFixedDimension(80, 80),
   cmp.text("DynamicReports").setStyle(titleStyle).setHorizontalAlignment(HorizontalAlignment.LEFT),
   cmp.text("Getting started").setStyle(titleStyle).setHorizontalAlignment(HorizontalAlignment.RIGHT))
 .newRow()
 .add(cmp.filler().setStyle(stl.style().setTopBorder(stl.pen2Point())).setFixedHeight(10)))
```

--------------------------------

### Maven Dependencies for DynamicReports

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Configuration.html

Add these dependencies to your pom.xml to include DynamicReports core, adhoc, and googlecharts modules in your Maven project. Ensure itext-2.1.7.js6 is accessible, potentially from the JasperReports Maven repository.

```xml
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-core</artifactId>
  <version>5.1.0</version>
</dependency>
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-adhoc</artifactId>
  <version>5.1.0</version>
</dependency>
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-googlecharts</artifactId>
  <version>5.1.0</version>
</dependency>
```

--------------------------------

### Setting Font Style in Java

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Fonts.html

Applies a specific font style to a text component using StyleBuilder. This demonstrates how to use the registered font in a report.

```java
StyleBuilder plainStyle = stl.style()
    .setFontName("FreeUniversal");
report().
    title(cmp.text("text - plain").setStyle(plainStyle))
```

--------------------------------

### Maven Dependencies for DynamicReports Snapshot Versions

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Configuration.html

Use these dependencies in your pom.xml to include development snapshot versions of DynamicReports. Update the version numbers to the desired snapshot release.

```xml
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-core</artifactId>
  <version>5.1.1-SNAPSHOT</version>
</dependency>
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-adhoc</artifactId>
  <version>5.1.1-SNAPSHOT</version>
</dependency>
<dependency>
  <groupId>net.sourceforge.dynamicreports</groupId>
  <artifactId>dynamicreports-googlecharts</artifactId>
  <version>5.1.1-SNAPSHOT</version>
</dependency>
```

--------------------------------

### Create Standard Columns

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Use col.column() to create new columns with optional titles, field names, and value classes or data types. This is the basic method for adding data columns to your report.

```java
report()
 .columns(
     col.column("Item", "item", type.stringType()),
     col.column("Quantity", "quantity", type.integerType()))
 .setDataSource(...)
```

--------------------------------

### Calculate Price Column

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Creates a new 'Price' column by multiplying the 'Unit price' column by the 'Quantity' column. This showcases arithmetic operations available for creating calculated columns in DynamicReports.

```java
//price = unitPrice * quantity
TextColumnBuilder<BigDecimal> priceColumn = unitPriceColumn.multiply(quantityColumn)
                                                          .setTitle("Price");
```

--------------------------------

### Setting Default Font in dynamicreports-defaults.xml

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Fonts.html

Configures the default font for all report components when no specific style is applied. This XML file allows setting a global default font name and size.

```xml
<DynamicReports>
<!-- DEFAULT FONT -->
    <font fontName="FreeUniversal" fontSize="10"/>
</DynamicReports>
```

--------------------------------

### Registering Font Extension in jasperreports_extension.properties

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Fonts.html

Registers the font configuration file with JasperReports. This properties file is used to extend the reporting engine's capabilities.

```properties
net.sf.jasperreports.extension.registry.factory.simple.font.families=net.sf.jasperreports.engine.fonts.SimpleFontExtensionsRegistryFactory
net.sf.jasperreports.extension.simple.font.families.drfonts=fonts.xml
```

--------------------------------

### Create Boolean Column

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Creates a new boolean column. It can display a boolean value as text or an image. Configuration options include setting the component type and image dimensions.

```java
report()
 .columns(
     col.booleanColumn("Boolean", "boolean"),
 col.booleanColumn("Boolean", "boolean").setComponentType(BooleanComponentType.IMAGE_STYLE_1))
 .setDataSource(...)
```

--------------------------------

### Define Custom Currency Data Type

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Create a custom currency data type by extending BigDecimalType and overriding the getPattern() method. This allows for consistent currency formatting across your reports.

```java
CurrencyType currencyType = new CurrencyType();

TextColumnBuilder<BigDecimal> unitPriceColumn = col.column("Unit price", "unitprice", currencyType);
//price = unitPrice * quantity
TextColumnBuilder<BigDecimal> priceColumn     = unitPriceColumn.multiply(quantityColumn).setTitle("Price")
                                                              .setDataType(currencyType);
private class CurrencyType extends BigDecimalType {
  private static final long serialVersionUID = 1L;

  @Override
  public String getPattern() {
    return "$ #,###.00";
  }
}
```

--------------------------------

### Create Expression Column

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Define an expression column using col.column() with a DRIExpression. The displayed values are determined by the provided expression, allowing for dynamic content.

```java
report()
 .columns(
     col.column("Expression column", new ExpressionColumn()))
 .setDataSource(...)
 private class ExpressionColumn extends AbstractSimpleExpression<String> {
 public String evaluate(ReportParameters reportParameters) {
     return ...;
 }
 }
```

--------------------------------

### Define Report Columns

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Defines the columns for a report using DynamicReports.col.column, specifying the column title, field name from the data source, and data type. This is a foundational step for structuring report data.

```java
.columns(//add columns
   //             title,     field name     data type
   col.column("Item",       "item",      type.stringType()),
   col.column("Quantity",   "quantity",  type.integerType()),
   col.column("Unit price", "unitprice", type.bigDecimalType()))
```

--------------------------------

### Apply Column Grid Layout

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Modifies the layout of columns in the title, details, and subtotal sections using `columnGrid()`. `grid.verticalColumnGridList()` can be used to define vertical arrangements within the grid.

```java
.columnGrid(
   rowNumberColumn, quantityColumn, unitPriceColumn,
   grid.verticalColumnGridList(priceColumn, pricePercColumn))
```

--------------------------------

### Create Report Row Number Column

Source: https://dynamicreports.readthedocs.io/en/latest/docs/Columns.html

Creates a new row number column for the report. The row number is reset on each new column. An optional title can be provided.

```java
report()
 .columns(
     col.reportRowNumberColumn("Report row"))
 .setDataSource(...)
```

--------------------------------

### Group Report Data

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Adds a grouping mechanism to the report based on a specified column, such as the 'item' column. This allows for summarizing and organizing data by categories.

```java
.groupBy(itemColumn)
```

--------------------------------

### Add Row Number Column

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Inserts a column that displays the sequential row number for each record in the report. The column can be configured with a fixed width and centered alignment for better readability.

```java
TextColumnBuilder<Integer> rowNumberColumn = 
   col.reportRowNumberColumn("No.")
   //sets the fixed width of a column, width = 2 * character width
   .setFixedColumns(2)
   .setHorizontalAlignment(HorizontalAlignment.CENTER);
```

--------------------------------

### Conditionally Print Group Subtotals

Source: https://dynamicreports.readthedocs.io/en/latest/GettingStarted.html

Hides subtotals for a group if it contains only one row. `exp.printWhenGroupHasMoreThanOneRow(itemGroup)` creates a boolean expression that evaluates to true only when the group has multiple rows.

```java
ColumnGroupBuilder itemGroup = grp.group(itemColumn);

itemGroup.setPrintSubtotalsWhenExpression(
           exp.printWhenGroupHasMoreThanOneRow(itemGroup));
.groupBy(itemGroup)
```
Tokens:
Raw