Charts can also contain parameters to either limit the data in some form. Typically, query (or IN) parameters are used by the data source to limit the data.

Query parameters can be both single value and multi-value parameter types.

When a parameterized template is opened using following constructor:

QbChart(Applet parent, String templateName);
          

a dialog box appears, asking for the value(s) of the parameter(s). This dialog box is the same as the one that appears in Designer when the template is opened.

Component doObjectArray(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	// Object array for Query Parameters
	Vector vec = new Vector();
	vec.add("CA");
	vec.add("NY");

	GregorianCalendar beginDate = new GregorianCalendar(2001, 0, 4);
	GregorianCalendar endDate = new GregorianCalendar(2003, 1, 12);

	long beginLong = beginDate.getTimeInMillis();
	long endLong = endDate.getTimeInMillis();

	Date beginDateTime = new Date(beginLong);
	Date endDateTime = new Date(endLong);

	Object queryParams[] = new Object[3];
	queryParams[0] = vec;
	queryParams[1] = beginDateTime;
	queryParams[2] = endDateTime;

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ObjectArray.cht", // template
			queryParams); // Query Parameters

	// Show chart in Viewer
	return chart;
}
            

Switching the data source to point to a database is simple. All you would need to do is provide the database connection information as well as the query to be used and pass that to the QbChart object. You can provide the database connection information (as well as the query) in a DBInfo object (for more information on creating a DBInfo object, please refer to Appendix 8.A.1 - Data from a Database).

The following example, which can be run as an applet or application, switches the data source of the QbChart object to a database:

Component doChartSwitchToDatabase(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	// Data Source
	DBInfo newDatabaseInfo = new DBInfo(..);

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ChartSwitchToDatabase.tpl"); // template

	try {
		// Switch data source
		chart.gethInputData().setDatabaseInfo(newDatabaseInfo);

		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
	}

	// Show chart in Viewer
	return chart;
}
          

Full Source Code

Exported Results

Please note that the above code is not complete and is there as a guide. However, the link contains a complete application code that can be run.

Component doChartSwitchToDatabaseJNDI(Applet parent)  {
		
	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);
		
	// Data Source.  Replace comp with computer and env with environment.
	// The environment hashtable is empty for tomcat.
	// If other application server is used, need to set INITIAL_CONTEXT_FACTORY and PROVIDER_URL. 
	DBInfo newDatabaseInfo = new DBInfo(...);
		
	// Open the template
	QbChart chart = new QbChart (parent,// container 
	"ChartSwitchToDatabaseJNDI.cht");	// template
		
	try {
		// Switch data source
		chart.gethInputData().setDatabaseInfo(newDatabaseInfo);
			
		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
	}
	
	// Show report in Viewer
	return chart;
}
            

You can switch the data source to a text file as long as the text file follows the Quadbase guidelines (for more details, please refer to Appendix 8.A.2 - Data from a Data File (TXT/DAT/XML)).

The following example, which can be run as an applet or application, switches the data source of the QbChart object to a text file:

Component doChartSwitchToDataFile(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ChartSwitchToDataFile.cht"); // template

	try {
		// Switch data source
		chart.gethInputData().setDataFile("surface.dat");

		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
	}

	// Show chart in Viewer
	return chart;
}
          

Full Source Code

Please note that the above code is not complete and is there as a guide. However, the link contains a complete application code that can be run.

You can switch the data source to your custom XML data as long as there is a .dtd or .xml schema accompanying your data. The XML data information is specified (for more details, please refer to Appendix 8.C.3 - Data from a XML Data Source) and then passed to the QbChart object.

The following example, which can be run as an applet or application, switches the data source of the QbChart object to XML data:

Component doChartSwitchToXMLData(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ChartSwitchToXMLData.cht"); // template

	// XML data source information
	String xmlfilename = "Inventory.xml";
	String xmlcondition = "";
	
	XMLFileQueryInfo xmlInfo = new XMLFileQueryInfo(...);

	try {
		// Switch data source
		chart.gethInputData().setXMLFileQueryInfo(xmlInfo);

		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
		}

	// Show chart in Viewer
	return chart;
}
          

Full Source Code

Exported Results

Please note that the above code is not complete and is there as a guide. However, the link contains a complete application code that can be run.

In addition to the regular data sources, you can also pass in your own custom data. The custom data is passed to the QbChart object using the IDataSource interface (for more details, please refer to Appendix 8.A.5 - Data passed in a Custom Implementation).

The following example, which can be run as an applet or application, switches the data source to a custom implementation:

Component doChartSwitchToCustomData(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ChartSwitchToCustomData.cht"); // template

	try {
		// Switch data source
		chart.gethInputData().setClassFile("Furniture_Chart");

		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
	}

	// Show chart in Viewer
	return chart;
}
          

Full Source Code

Exported Results

Please note that the above code is not complete and is there as a guide. However, the link contains a complete application code that can be run.

You can also pass in data using arrays. The array data is usually stored is memory and passed to the QbChart object (for more details, please refer to Appendix 8.A.4 - Data passed in an Array in Memory).

The following example, which can be run as an applet or application, switches the data source to an array in memory:

Component doChartSwitchToArrayData(Applet parent) {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	DbData newData = new DbData(...);

	ColInfo colInfo = new ColInfo();
	colInfo.category = 0;
	colInfo.value = 1;
	colInfo.subvalue = 2;

	// Open the template
	QbChart chart = new QbChart(parent, // container 
			"ChartSwitchToArrayData.cht"); // template

	try {
		// Switch data source
		chart.gethInputData().setData(newData);

		// Refresh chart
		chart.refresh();
	} catch (Exception ex)
	{
		ex.printStackTrace();
	}

	// Show chart in Viewer
	return chart;
}
          

Full Source Code

Exported Results

Please note that the above code is not complete and is there as a guide. However, the link contains a complete application code that can be run.

A chart is comprised of different elements (for instance, the canvas, the axis, the legend, the chart data, etc). Each element can be modified independently of the other by getting the appropriate interface and changing the properties by calling the methods therein.

For instance, the following code sets the background color of the chart to white:

chart.gethCanvas().setBackgroundColor(Color.white);    // chart being an object of type QbChart
          

while the code given below changes the color of the X axis to black:

chart.gethXAxis().setColor(Color.black);              // chart being an object of type QbChart
          

You can also set the color of the data elements of the chart based on the series or based on the category (if no series is defined). For example, if the chart is a Column chart with five elements in the series, the following code sets the columns colors in the series, to be yellow, orange, red, green, and blue.

Color dataColors[] = {Color.yellow, Color.orange, Color.red, Color.green, Color.blue};
chart.gethDataPoints().setColors(dataColors);        // chart being an object of type QbChart
          

	Note
	The number of colors defined must match the number of unique elements in the series (or the category if the series is not defined).

Similarly, the font styles can be set by calling the appropriate interface and using the method. The following code sets the text used in the legend to be of Arial, bold type, and size 15.

Font legendFont = new Font("Arial", Font.BOLD, 15);
chart.gethLegend().setFont(legendFont);             // chart being an object of type QbChart
          

while the following code sets the font and color of the labels used in the Y Axis:

Font YAxisFont = new Font("Helvetica", Font.ITALIC, 15);
chart.gethYAxis().gethLabel().setFont(YAxisFont);    // chart being an object of type QbChart
chart.gethYAxis().gethLabel().setColor(Color.blue);  // chart being an object of type QbChart
          

Similarly, other properties can be set using the methods in the interfaces.

The class QbPattern is a subclass of java.awt.Color, so there is no new method introduced to set patterns explicitly. You create a QbPattern object first, and then use it as if it is a Color object. The pattern feature is only applicable to data points. For other chart elements (such as axis, canvas), ERES will ignore the QbPattern properties, and use it just like a Color.

The following example, which can be run as an applet or application, shows how to set a pattern to a data point:

Color[] dataColors = chart.gethDataPoints().getColors();
QbPattern dataPattern = new QbPattern(colors[2], QbChart.PATTERN_THICK_FORWARD_DIAGONAL);
dataColors[2] = dataPattern;
chart.gethDataPoints().setColors(dataColors);
          

Full Source Code

Exported Results

There are totally 30 predefined patterns available for you to use. The pattern ID range from 0 to 29. If the user passes an integer beyond this range, it will be considered as ID = 0, which is a solid color block. The Pattern ID is defined in quadbase.ChartAPI.IMiscConstants class as well as in quadbase.common.swing.color.PatternImage class. Since QbChart implements the IMiscConstants interface, you can obtain these IDs directly from QbChart. You can also see what each pattern looks like in the pattern palette Designer.

You can also set up your own pattern (texture) images. This feature is only available via API and the modification will not be saved to the template. This feature is mainly for those who want to modify the chart during the run time.

The following example, which can be run as an applet or application, shows how to set a custom pattern to a data point:

Color[] dataColors = chart.gethDataPoints().getColors();
QbPattern dataPattern = new QbPattern(dataColors[2]);
File customImageFile = new File("Quadbase_Logo.png");
BufferedImage customImage = ImageIO.read(customImageFile);
dataPattern.setPatternImage(customImage);
dataColors[2] = dataPattern;
chart.gethDataPoints().setColors(dataColors);
          

Full Source Code

Exported Results

In the above code, a QbPattern object is created without specifying the pattern ID. The newly created object is equivalent to a java.awt.Color object. The developer is responsible for providing an image so as to avoid the NullPointerException prompting in the procedure. An existing image (from a file) is then passed as the pattern for data point two.

There are two sizes to be considered when creating a chart:

Every element of the chart (where the size parameter is used) is defined relative to the chart canvas. A float is used to represent the relative size of the chart element. For instance, the following code sets the chart plot height to .85 and the chart plot width to .65:

chart.gethChartPlot().setRelativeHeight(.85f);    // chart being an object of type QbChart
chart.gethChartPlot().setRelativeWidth(.65f);     // chart being an object of type QbChart
          

The code given below sets the canvas size of the chart:

Dimension canvasSize = new Dimension(500, 450);
chart.gethCanvas().setSize(canvasSize);           // chart being an object of type QbChart
          

Similarly, the sizes of the other elements can be set using the methods in the interfaces.

You can modify the properties (such as scale and starting/ending time perion) of a Date/Time Zoom template created in the Designer. This is done by getting a handle to the Zoom properties (using the IZoomInfo interface) and using the various methods there to change the presentation.

The following example, shows how to modify a Date/Time Zoom chart and can be run as an applet or application:

// Modify starting and ending period and scale
IZoomInfo zoomInfo = chart.gethZoomInfo();

// Begin Date
Calendar beginDate = new GregorianCalendar(2001, 0, 1);

// End Date
Calendar endDate = new GregorianCalendar(2003, 11, 31);

zoomInfo.setLowerBound(beginDate.getTime());
zoomInfo.setUpperBound(endDate.getTime());

zoomInfo.setScale(6, IZoomInfo.MONTH);

chart.refresh();
          

Full Source Code

Exported Results

In the above code, chart is an object of type QbChart.

	Note
	After modifying the chart's zoom properties, the chart must be refreshed for the modified properties to take effect.

While stand-alone charts can be modified directly using the API, any charts in a report (whether the chart is independent or not) cannot be modified as easily. You can change the look and feel of a chart (in a report) by implementing IChartModifier interface to create a class that invokes the desired changes. Note that the actual chart template is not changed, merely the chart's appearance within the report.

The following example, which can be run as an applet or application, shows how to modify a chart in a report:

ReportChartObject[] reportCharts = report.getReportChartObjects();
for (int i = 0; i < reportCharts.length; ++i)
{

      reportCharts[i].setChartModifier(new ModifyChart());

}

public class ModifyChart implements IChartModifier {

      public IChart modifyChart(Object chartInfo) {
            ChartObject chart = new ChartObject(chartInfo); // Get actual ChartObject
            chart.gethCanvas().setBackgroundColor(Color.white);
            return chart; }

}
          

Full Source Code

Exported Results Before Modification

Exported Results After Modification

ERES also has record file exporting to handle large amounts of data. In record file exporting, you specify the number of records to be held in memory and a temp directory. When the number of records in the data exceeds the number specified to be held in memory, the data is stored on disk in the temp directory specified.

There are certain conditions that have to be met before you can use this feature. You must:

To use record file export, the following code must be added before calling the QbChart constructor:

QbChart.setEspressManagerUsed(false);
QbChart.setTempDirectory(<specify the temp directory to store data. Default is ./temp>);
QbChart.setMaxCharForRecordFile(<specify the maximum character length. Default is 40>);
QbChart.setMaxRecordInMemory(<specify the maximum number of rows to be kept in memory. Default is -1 i.e., store all records in memory>);
QbChart.setFileRecordBufferSize(<specify the number of rows to be retrieved at one time from disk. Default is 10,000>);
          

In addition to exporting to local drives, charts can also be exported as a byte stream and streamed directly to a web browser. Note that server-side code typically exports the image only in a binary format. You are responsible for creating a wrapper (i.e. DHTML content) around the exported image.

An example that exports a chart to PNG and streams it to the browser is given below. In order to run the example, you will need to configure and compile the source code, then deploy the class file in the servlet directory of your servlet runner. Replace the chartTemplate variable with either an absolute path or a path relative to the working directory of your application server.

public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
	IOException {

	// Do not use EspressManager
	QbChart.setEspressManagerUsed(false);

	String chartTemplate = "StreamingChart.cht";

	// Open template
	QbChart chart = new QbChart((Applet) null, chartTemplate);

	// Export the chart to PNG and stream the bytes
	ByteArrayOutputStream chartBytes = new ByteArrayOutputStream();

	try {
		// Export chart
		chart.export(QbChart.PNG, chartBytes);
	} catch (Exception ex){
		ex.printStackTrace();
	}

	resp.setContentType("image/x-png");
	resp.setContentLength(chartBytes.size());

	OutputStream toClient = resp.getOutputStream();
	chartBytes.writeTo(toClient);
	toClient.flush();
	toClient.close();
}
          

Full Source Code

To run the example, make sure to copy the chart template to the location accessed by the code. If using a relative path (as shown in the example), remember that the current directory is the working directory of your application server. For example, since the working directory in Tomcat is <Tomcat>/bin, you will need to create the directory <Tomcat>/templates/ and copy the chart template there to run the code. The resulting chart is shown below.

Streaming Chart

The following features describe the various visual changes that can be made to the chart plot and/or canvas using the API. Note that the features below deal with general changes to the chart plot and/or canvas. Any component specific change is described in its own section.

INoDataToPlotMessage noData = chart.gethNoDataToPlotMessage();
noData.setMessage("Not enough data to plot chart");
            

ICanvas canvas = chart.gethCanvas();
canvas.setFitOnCanvas(true);
            

ICanvas canvas = chart.gethCanvas();
canvas.setChartVisible(false);
            

chart.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
            

chart.forceApplyAntiAliasToHorizontalText(true);
            

IPlot chartPlot = chart.gethChartPlot();
chartPlot.setPosition(new Position(-0.5, -0.5));
            

// Open the template
QbChart primaryChart = new QbChart(parent, // container 
		"AddOnChart1.cht"); // template

// Open other two templates
QbChart chart2 = new QbChart(parent, "AddOnChart2.cht");
QbChart chart3 = new QbChart(parent, "AddOnChart3.cht");

primaryChart.setAddOnChart(new QbChart[] { chart2, chart3 });
            

The following features describe the various visual changes that can be made to the chart hint box using the API. These include modifying the content as well as look of the hint box.

// Open the template
QbChart chart = new QbChart(parent,                                          // container
                            "../templates/ModifyHintBox.cht"); // template

IHintBoxInfo hintBoxInfo = new Hint();
chart.gethDataPoints().gethHint().setHintBoxInfo(hintBoxInfo);

...

class Hint implements IHintBoxInfo {

      public Vector getHint(PickData pickData) {
            Vector vec = new Vector();

            if (pickData.series != null)
                  vec.addElement("(" + pickData.seriesName+ ") " + pickData.s_series);

            if (pickData.category != null)
                  vec.addElement("(" + pickData.categoryName + ") " + pickData.s_category);

            if (pickData.s_value != null)
                  vec.addElement("(" + pickData.valueName + ") " + pickData.s_value + (pickData.value > 7 ? ":Good" : ":Restock"));

            return vec;

      }

}
            

IHint dataHints = chart.gethDataPoints().gethHint();
dataHints.setoffset(new Dimension (30, 20));
            

IHint chartHintBox = chart.gethHint();
chartHintBox.setBorderColor(Color.red);
            

// Open the template
QbChart chart = new QbChart(parent, // container 
		"CustomizeImageMapHintBox.cht"); // template

chart.setImageMapDataHintBoxHandle(new customizeImageMap());

try {
	// Export chart to image and map file
	chart.export(QbChart.PNG, "CustomizeImageMapHintBox", "CustomizeImageMapHintBox", 0, 0,
			true);
} catch (Exception ex)
{
	ex.printStackTrace();
}

...

class customizeImageMap implements ICustomizeImageMapDataHintBox {

	public String customizeHintBox(String str) {
		return str.substring(8, 11) + " " + str.substring(str.length() - 3);
	}
}
            

The following features describe the various visual changes that can be made to the chart legend and/or any annotation using the API. These include modifying the content as well as look of the chart legend/annotations.

// Open the template
QbChart chart = new QbChart(parent,                                                 // container
                            "../templates/AnnotationWithSymbol.cht"); // template

// Create custom legend
IAnnotationSet set = chart.gethAnnotations();
String[] text = {"New Legend", "Hello World", "ABC", "I got It"};
int[] shape = {QbChart.PLUS, QbChart.NOSYMBOL, QbChart.SQUARE, QbChart.DASH};
Color[] color = {Color.red, Color.black, Color.blue, Color.white};
IAnnotation anno = set.newAnnotation(text, shape, color);
Point_2D newPosition = new Point_2D(.7f, .7f);
anno.setRelativePosition(newPosition);
set.addAnnotation(anno);
            

void setxShift(int x);
void setyShift(int y);
            

ICanvas canvas = chart.gethCanvas();
canvas.setReferenceAtTop(true);
            

The following features describe the various visual changes that can be made to the different components of the chart. These include modifying both the content as well as the look of the chart and its elements.

IAxis hXAxis=chart.gethXAxis();
hXAxis.setTickerLabels(new String[] {new String("a"), new String("b"), new String("c")});
            

// Open the template
QbChart chart = new QbChart(parent, // container 
	"CustomizeDataTopLabel.cht"); // template

chart.gethDataPoints().setDataLabelInfo(new customizeDataTopLabel());
		
...

class customizeDataTopLabel implements IDataLabelInfo {

      public String getDataLabel(PickData pickData, String originalDataLabel) {
            return (pickData.toString());
      }

}
            

IAxis chartYAxis = chart.gethXAxis();
chartXAxis.setDisplayLabelAsDate(true);
            

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setDisableJava2DForStraightText(true);
            

ILinePropertySet lineProperties = chart.gethLineProperties();
lineProperties.setDataDrawnOnTop(true);
            

ERES allows you to get the information of a datapoint based on a specified pixel position. This returns the category, value, series, and sumby (if they are there) of the data point at the specified pixel location and otherwise returns null.

To get pickData, use the method getPickData(width, height) in IHint.

IDataPointSet dataPoints=chart.gethDataPoints();
IHint hint=dataPoints.gethHint();
PickData pickdata=hint.getPickData(200, 300)        // pixel at width=200 and height=300
          

Please refer to the online API documentation for more information (quadbase.util.IHint).

When a manual axis is applied, ERES gives you the option to truncate data points that are beyond the maximum value on the axis. You can set the data limit by using the method setLimitAtAxisScale in IDataPointSet.

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setLimitAtAxisScale(true);
          

Please refer to the online API documentation for more information (quadbase.util.IDataPointSet).

ERES can now represent any null data as zero data (i.e. datapoints with an associated 0 value). To accomplish this, use the setNullDataAsZero method in IDataPointSet.

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setNullDataAsZero(true);
          

Please refer to the online API documentation for more information (quadbase.util.IDataPointSet).

ERES allows you to get the minimum, the maximum, the probability and the inverse normal. In addition, you can get the mean value for the normal curve trend line and draw standard deviation trend lines by calling ITrendLine and using the appropriate method.

To utilize this feature in the API, call ITrendLine and use the appropriate methods.

Note that you can only draw standard deviation trend lines for a normal curve if the chart is a histogram chart with setLinearScale and setRounded true.

The following code, which can be run as an applet or application, shows how to get information from a normal curve trendline in the chart:

ITrendLine normalCurve = (ITrendLine)chart.gethDataLines().elements().nextElement();
System.out.println("Mean = " + normalCurve.getMean());
System.out.println("St. Dev = " + normalCurve.getStandardDev());
System.out.println("Min = " + normalCurve.getMin());
System.out.println("Max = " + normalCurve.getMax());
System.out.println("Dev of 1.0, Prob = " + normalCurve.getProbability(1.0));
System.out.println("Back Calculated Dev = " + normalCurve.getInverseNorm(normalCurve.getProbability(1.0)));
          

Full Source Code

Exported Image

Please refer to the online API documentation for more information (quadbase.util.ITrendLine).

ERES allows you to draw the minimum, the maximum, the average in addition to the stand deviation lines of any level exsisting in the stack data together, by calling newControlLine(int linetype, String label, int level) method with proper parameters setting.

To utilize this feature in the API, you need to set the right parameter value, for the parameter of linetype: MINIMUM = 12, MAXIMUM = 13, CONTROL_AVERAGE = 10, STANDARD_DEVIATION = 11.

The parameter of label is the text dispaly in the legend.

The last parameter of level is the level of the data display int the stack chart.

	Note
	This feature only works for Stack Type Chart, i.e., stack column, stack bar and stack area. For stack column chart with combo type is stack area, this feature only works for the main axis data, that is, stack column chart.

The following code, which can be run as an applet or application, shows how to draw multiple control lines to a stack area chart:

QbChart chart = new QbChart(this, QbChart.VIEW2D, QbChart.STACKAREA, "sample.dat",colInfo);

IDataLineSet hDataLines = chart.gethDataLines();

IControlLine clLine1 = hDataLines.newControlLine(13, "Max4", 4);  
IControlLine clLine2 = hDataLines.newControlLine(13, "Max3", 3);
IControlLine clLine3 = hDataLines.newControlLine(13, "Max2", 2);  
IControlLine clLine4 = hDataLines.newControlLine(13, "Max1", 1);
IControlLine clLine5 = hDataLines.newControlLine(10, "Avg4", 4);
clLine1.setColor(Color.RED);
clLine2.setColor(Color.YELLOW);
clLine3.setColor(Color.GREEN);
clLine4.setColor(Color.BLUE);
clLine5.setColor(Color.GRAY);
hDataLines.add(clLine1);
hDataLines.add(clLine2);
hDataLines.add(clLine3);
hDataLines.add(clLine4);
hDataLines.add(clLine5);

Full Source Code

Exported Image

Please refer to the online API documentation for more information (quadbase.util.IControlLine).

The following features describe the various changes that can be made to column/bar charts using the API. These include modifying the content as well as look of the chart.

IDataPointSet hDataPoints=chart.gethDataPoints();
hDataPoints.setColorSeparators(new Color[]{Color.green, Color.red, Color.blue},
                               new Integer[]{new Integer((int)Math.rint(9)), new Integer((int)Math.rint(14))},
                               QbChart.ASCENDING);
            

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setShowShadowOnPoint(false);
            

The following features describe the various changes that can be made to pie charts using the API. These include modifying the content as well as look of the chart.

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.reverseOrder(QbChart.CATEGORY);
            

IPiePropertySet pieProperties = chart.gethPieProperties();
pieProperties.setRadialBorderForZero(true);
            

IPiePropertySet pieProperties = chart.gethPieProperties();
pieProperties.setSepSymbol(",");
            

IPiePropertySet pieProperties = chart.gethPieProperties();
pieProperties.setBorderColor(Color.red);
            

The following features describe the various changes that can be made to line charts using the API. These include modifying both the content and the look of the chart.

ILinePropertySet lineProperties = chart.gethLineProperties();
lineProperties.setAreaVisible(true);
lineProperties.setAreaColors(Color.green, Color.yellow);
            

The following features describe the various changes that can be made to scatter charts using the API. These include modifying the content as well as look of the chart.

IDataPointSet dataPoints=chart.gethDataPoints();
dataPoints.showSeriesInTopLabel(true);
            

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setConnectLinesInOriginalOrder(true);
            

IDataPointSet dataPoints = chart.gethDataPoints();
dataPoints.setScatterCubeWidth(15);
            

The following features describe the various changes that can be made to overlay charts using the API. These include modifying the content as well as look of the chart.

IAxis axis0 = chart.gethYAxis();
axis0.gethTitle().setValue("XYZ");

IAxis axis1 = chart.gethAxis(1); // Get axis of Layer 1
axis1.gethTitle().setValue("ABC");

IAxis axis2 = chart.gethAxis(2); // Get axis of Layer 2
axis2.gethTitle().setValue("DEF");
            

The following features describe the various changes that can be made to dial charts using the API. These include modifying the content as well as look of the chart.

ControlRange cr1 = chart.gethControlRanges().elementAt(0);
cr1.setShowLabel(true);
            

The following features describe the various changes that can be made to HLCO charts using the API. These include modifying the content as well as look of the chart.

IDataPointSet dataPoints = chart.gethDataPoints();
// Up color is green, Down color is red
dataPoints.setCandleStickColors(Color.green, Color.red);
            

IDataPointSet dataPoints = chart.gethDataPoints();
// Set width to 0.5
dataPoints.setCandleStickWidth((float)0.5);
            

The following features describe the various changes that can be made to surface charts using the API. These include modifying the content as well as look of the chart.

double [] heatMapValues = {3, 6};
Color [] heatMapColors = { Color.green, Color.yellow, Color.red};
ColorSpectrum heatMapColorSpectrum = new ColorSpectrum(heatMapColors, heatMapValues);
I3DPropertySet set = chart.geth3DProperties();
set.setColorSpectrum(heatMapColorSpectrum);
            

ERES allows the choice of using either java.awt.image.BufferedImage or java.awt.Frame during export to improve performance. By default, ERES uses java.awt.Frame to create the chart object. Using java.awt.Frame gives better performance as the number of data points increases while using java.awt.image.BufferedImage yields better performance on larger chart dimensions. This is done by using the setBufferedImageUsed method in QbChart.

chart.setBufferedImageUsed(true);
          

Please refer to the online API documentation for more information (quadbase.ChartAPI.QbChart).

This functionality is only available for stand-alone charts.

ERES allows you to choose the order in which the chart is generated and even add elements in the generation of the chart using the API only. For example, you can draw a background and a circle and then have the chart generated in the center of the circle to create a chart. You can do this by creating a class that implements the IChartGraphics interface and then assigning the class to the setChartGraphics method in QbChart. In essence, the IChartGraphics interface allows you to add or modify any graphics information before or after drawing the chart.

The following code, which can be run as an applet or application, shows how to generate charts and graphics in a specific order:

// Open the template
QbChart chart = new QbChart(parent, // container 
	"ChartGeneration.cht"); // template

chart.setChartGraphics(new chartGenerationGraphics());

...

class chartGenerationGraphics implements IChartGraphics {

      public void initializeGraphics(Graphics g, int w, int h) {
            g.setColor(Color.red);
            g.fillOval(50, 50, 400, 400);

      }

      public void finalizeGraphics(Graphics g, int w, int h) {
            g.setColor(Color.white);
            g.fillOval(125, 225, 50, 50);
            g.setColor(Color.orange);
            g.drawString("HELLO WORLD", 150, 250);

      }

}
          

Full Source Code

Exported Image

Please refer to the online API documentation for more information (quadbase.util.IChartGraphics).

This functionality is only available for stand-alone charts.

ERES has a call back mechanism for higher levels to handle the event. An action event is generated when a data object in the chart is selected by the viewer. The event argument contains an instance of PickData, which provides information of the series, category, value, etc, of the data point selected.

The following code, which can be run as an applet or application, shows how to capture an event:

static TextField textField;

// Open the template
QbChart chart = new QbChart(parent, // container 
	"CallBack.cht"); // template

chart.addActionListener(new callBackActionListener());

...

class callBackActionListener implements ActionListener {

      public void actionPerformed(ActionEvent e) {
            Object arg = ((QbChart) e.getSource()).getArgument();

            String click;

            switch (e.getModifiers()) {

            case QbChart.LEFT_SINGLECLICK:
                  click = "Left single click";
                  break;

            case QbChart.LEFT_DOUBLECLICK:
                  click = "Left double click";
                  break;

            case QbChart.RIGHT_SINGLECLICK:
                  click = "Right single click";
                  break;

            case QbChart.RIGHT_DOUBLECLICK:
                  click = "Right double click";
                  break;

            default: // shall not happen
                  click = "Error !";

            }

            if (arg instanceof PickData)
                  textField.setText(((PickData) arg).toString() + " " + click);

            else
                  textField.setText((String) arg + " " + click);

      }

}
          

Full Source Code

Exported Image

This functionality is only available for stand-alone charts.

ERES allows the tool-tips text for the navigation panel to be enabled and disabled. This can be done by using the method setToolTipEnabled in I3DControlPanel. Note that this option is for 3D charts only.

I3DControlPanel controlPanel = chart.geth3DControlPanel();
controlPanel.setToolTipEnabled(true);
          

Please refer to the online API documentation for more information (quadbase.util.I3DControlPanel).

ERES allows the viewpanel containing the canvas to be selected so that more event properties (i.e. user defined event properties) can be added. You can do this by getting a handle to ICanvas and using the getCanvasArea() method to return the component.

ICanvas chartCanvas = chart.gethCanvas();
Component chartCanvasComponent = chartCanvas.getCanvasArea();
          

Please refer to the online API documentation for more information (quadbase.util.ICanvas).