Of course! Here is a comprehensive guide to using ChartDirector in Java, covering what it is, how to get started, and providing detailed code examples for common chart types.

What is ChartDirector?

ChartDirector is a professional, feature-rich charting component library for Java (as well as for C++, C#, ActiveX, and PHP). It's developed by Advanced Software Engineering (ASE) and is known for its high-quality output, extensive customization options, and excellent performance.

Key Features:

• High-Quality Rendering: Produces publication-quality charts with anti-aliasing and smooth lines.
• Wide Variety of Chart Types: Supports all common charts (Line, Bar, Pie, Area, Scatter, etc.) and specialized financial charts (Candlestick, OHLC).
• Extensive Customization: You have fine-grained control over almost every visual aspect of the chart, including colors, fonts, labels, axes, legends, and annotations.
• Easy Integration: Designed to work seamlessly with Swing, JavaFX, and can also generate images (PNG, JPG, SVG) for web applications or reports.
• Performance: Optimized for speed and efficiency, even with large datasets.

Getting Started: Setup and Dependencies

The core of ChartDirector is a single JAR file. The easiest way to add it to your project is through a build tool like Maven or Gradle.

Using Maven

Add the following dependency to your pom.xml file. You can find the latest version on the Maven Central Repository.

<dependency>
    <groupId>com.advancedsw.chartdirector</groupId>
    <artifactId>ChartDirector</artifactId>
    <version>7.0 (Check for the latest version)</version>
</dependency>

Note: ChartDirector is a commercial product. The version available on Maven is often a "Lite" or evaluation version. For full features and a license, you may need to purchase it from the official website.

Manual Download

1. Go to the Official ChartDirector Website.
2. Download the evaluation version or purchase a license.
3. Add the chartdirector.jar file to your project's classpath.

The Core Concepts: The ChartDirector API

Understanding the basic objects is key to using ChartDirector effectively.

• Chart: This is the central object. It represents the entire chart, including the plot area, axes, title, and legend. You create it and then customize it.
• Layer: Represents a layer on the chart. This is crucial for creating combination charts (e.g., a bar chart with a line overlay). You add different data series as different layers.
• DataSet: Holds the data for a single data series (e.g., the sales figures for one product). It can also store error bars.
• Color: A class for representing colors. You can use predefined colors (Color.RED, Color.BLUE) or create custom ones.
• XYChart: The most common chart class, used for charts with X and Y axes (like line, bar, and area charts).
• PieChart: A specialized class for creating pie charts.

Example 1: A Simple Line Chart in Swing

This is a classic "Hello, World!" for charting. We'll create a window with a simple line chart.

import com.advancedsw.chartdirector.*;
import javax.swing.*;
import java.awt.*;
public class SimpleLineChart {
    public static void main(String[] args) {
        // The data for the chart
        double[] data = {30, 28, 40, 55, 75, 68, 90};
        String[] labels = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
        // Create a XYChart object (600 x 400 pixels)
        XYChart c = new XYChart(600, 400);
        // Add a title to the chart
        c.addTitle("Weekly Sales Performance", "Arial Bold", 20, Color.darkGray);
        // Set the plot area at (50, 55) and of size 500 x 300 pixels, with a light grey
        // background and a 1 pixel 3D border.
        c.setPlotArea(50, 55, 500, 300, 0xf0f0f0, 0xc0c0c0, -1);
        // Add a legend box at (50, 320) (top center of the plot area) with horizontal layout.
        c.addLegend(50, 320, false, "Arial Bold", 12).setAlignment(Chart.TopCenter);
        // Add a title to the y-axis
        c.yAxis().setTitle("Sales (in USD)");
        // Add a title to the x-axis
        c.xAxis().setTitle("Day of the Week");
        // Set the labels on the x-axis.
        c.xAxis().setLabels(labels);
        // Add a line chart layer using the given data
        LineLayer lineLayer = c.addLineLayer(data, Chart.colorDarkGreen(), "Sales (Weekly)");
        // Set the line width to 3 pixels
        lineLayer.setLineWidth(3);
        // Output the chart in a Swing JFrame
        JFrame frame = new JFrame("Simple Line Chart");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new ChartViewer(c));
        frame.pack();
        frame.setVisible(true);
    }
}

How to Run This:

1. Ensure you have chartdirector.jar in your classpath.
2. Compile and run the SimpleLineChart class.
3. A window will appear displaying the chart.

Example 2: A Bar Chart with a Line Overlay (Combination Chart)

This example demonstrates how to use Layer to combine different chart types. We'll show sales as bars and the target as a line.

import com.advancedsw.chartdirector.*;
import javax.swing.*;
import java.awt.*;
public class CombinationChart {
    public static void main(String[] args) {
        // Data for the chart
        double[] salesData = {100, 125, 245, 147, 67, 178};
        double[] targetData = {120, 125, 200, 150, 100, 200};
        String[] labels = {"Jan", "Feb", "Mar", "Apr", "May", "Jun"};
        // Create an XYChart object (600 x 400 pixels)
        XYChart c = new XYChart(600, 400);
        // Add a title
        c.addTitle("Monthly Sales vs Target", "Arial Bold", 18, Color.darkGray);
        // Set the plot area
        c.setPlotArea(50, 60, 500, 280, 0xffffff, 0xeeeeee, 0);
        // Add a legend
        c.addLegend(50, 340, false, "Arial Bold", 12).setAlignment(Chart.TopCenter);
        // Add a title to the y-axis
        c.yAxis().setTitle("Amount (USD)");
        // Add a title to the x-axis
        c.xAxis().setTitle("Month");
        // Set the labels on the x-axis.
        c.xAxis().setLabels(labels);
        // Add a bar layer for the sales data
        BarLayer barLayer = c.addBarLayer(salesData, Chart.colorLightBlue(), "Sales");
        barLayer.setBorderColor(Chart.colorTransparent); // No border for a cleaner look
        // Add a line layer for the target data
        LineLayer lineLayer = c.addLineLayer(targetData, Chart.colorRed(), "Target");
        lineLayer.setLineWidth(3);
        lineLayer.getDataSet().setDataSymbol(Chart.CircleSymbol, 8, Chart.colorRed()); // Add data points
        // Display the chart in a JFrame
        JFrame frame = new JFrame("Combination Chart");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new ChartViewer(c));
        frame.pack();
        frame.setVisible(true);
    }
}

Example 3: A Pie Chart

Pie charts are created using the PieChart class, which is simpler than XYChart.

import com.advancedsw.chartdirector.*;
import javax.swing.*;
import java.awt.*;
public class SimplePieChart {
    public static void main(String[] args) {
        // The data for the pie chart
        double[] data = {25, 18, 15, 22, 20};
        String[] labels = {"Asia", "Europe", "North America", "South America", "Africa"};
        int[] colors = {Chart.colorDarkGreen(), Chart.colorOrange(), Chart.colorDeepSkyBlue(), Chart.colorPurple(), Chart.colorRed()};
        // Create a PieChart object (400 x 400 pixels)
        PieChart c = new PieChart(400, 400);
        // Add a title
        c.addTitle("Global Market Share 2025", "Arial Bold", 16, Color.darkGray);
        // Set the data and the labels
        c.setData(data, labels);
        // Set the pie chart colors
        c.setColors2(Chart.DataColor, colors);
        // Use the side label layout method
        c.setLabelLayout(Chart.SideLayout);
        // Set the label box style with rounded corners and semi-transparent light grey fill
        c.setLabelStyle().setBackground(0xf0f0f0, 0x808080, Chart.Transparent);
        // Draw the pie in 3D
        c.set3D();
        // Output the chart
        JFrame frame = new JFrame("Simple Pie Chart");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new ChartViewer(c));
        frame.pack();
        frame.setVisible(true);
    }
}

Generating an Image File (e.g., for Web)

You don't always need to display the chart in a Swing window. You can easily save it as an image file.

import com.advancedsw.chartdirector.*;
public class GenerateImage {
    public static void main(String[] args) {
        // (Use the same chart creation code as in the examples above)
        // For demonstration, let's reuse the simple line chart.
        double[] data = {30, 28, 40, 55, 75, 68, 90};
        String[] labels = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
        XYChart c = new XYChart(600, 400);
        c.addTitle("Weekly Sales Performance");
        c.setPlotArea(50, 55, 500, 300, 0xf0f0f0, 0xc0c0c0, -1);
        c.xAxis().setLabels(labels);
        c.addLineLayer(data, Chart.colorDarkGreen());
        // Save the chart as a PNG file
        c.makeChart("sales_chart.png");
        // Save as a JPG file
        // c.makeChart("sales_chart.jpg");
        // Save as a SVG file (vector format)
        // c.makeChart("sales_chart.svg");
        System.out.println("Chart image 'sales_chart.png' has been generated.");
    }
}

After running this, you will find a sales_chart.png file in your project's root directory.

Important Considerations

• Licensing: ChartDirector is a commercial product. The evaluation version is fully functional but may have limitations on the number of charts you can generate or may add a watermark. For production use, you must purchase a license.
• Documentation: The official ChartDirector Java Documentation is your best friend. It contains detailed API references and hundreds of examples.
• ChartViewer Component: The ChartViewer component is a lightweight Swing component designed specifically to display ChartDirector charts. It's the recommended way to embed charts in Swing applications.