gvSIG tools: basic charts

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.chart.lib.impl</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.chart.lib.impl</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.chart.lib</artifactId>

		<version>1.0.151</version>

	</parent>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.chart.lib.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.jfree</groupId>

			<artifactId>jfreechart</artifactId>

		</dependency>

		 <dependency>

		   <groupId>com.itextpdf</groupId>

		   <artifactId>itextpdf</artifactId>

		   <type>jar</type>

		 </dependency>

		 <dependency>

		   <groupId>com.itextpdf.tool</groupId>

		   <artifactId>xmlworker</artifactId>

		   <type>jar</type>

		 </dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.control</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.geometry.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.compat.api</artifactId>

            <scope>compile</scope>

		</dependency>		

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.symbology.lib.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.symbology.lib.impl</artifactId>

			<scope>compile</scope>

		</dependency>	

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.api</artifactId>  

            <scope>compile</scope>      

        </dependency>

		<dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.cresques.impl</artifactId>  

            <scope>compile</scope>      

        </dependency>  

	</dependencies>

</project>

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	org.gvsig.tools packages.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.chart">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="DEBUG" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

package org.gvsig.chart.impl;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import junit.framework.TestCase;

import org.gvsig.chart.impl.model.DefaultChartDataSet;

import org.gvsig.chart.model.ChartDataSet;

public class TestChartDataSet extends TestCase {

	public void testAddData() {

		ChartDataSet dataSet = new DefaultChartDataSet();

		String[] test = {"uno", "dos", "tres"};

		List t = Arrays.asList(test);

		dataSet.addData("test", t.iterator());

		Iterator<Object> it = dataSet.getValues("test");

		while (it.hasNext()) {

			System.out.println(it.next());

		}

		it = dataSet.getValues("test");

		while (it.hasNext()) {

			System.out.println("Segunda pasada:" + it.next());

		}

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.chart.impl;

import junit.framework.TestCase;

import org.gvsig.chart.ChartManager;

/**

 * {@link ChartManager} API compatibility tests for the

 * {@link DefaultChartManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultChartManagerTest extends TestCase {

    // Nothing to add

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.chart.impl;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartManager;

import org.gvsig.chart.ChartProperties;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.GroupedCharts;

import org.gvsig.chart.impl.model.DefaultChartDataSet;

import org.gvsig.chart.lib.spi.ChartServiceManager;

import org.gvsig.chart.model.ChartDataSet;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.service.AbstractMultiServiceImplManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

/**

 * Default {@link ChartManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultChartManager extends AbstractMultiServiceImplManager implements ChartManager {

	private I18nManager i18nmanager;

	public DefaultChartManager() {

		super(ChartLocator.getServiceManager());

		this.i18nmanager = ToolsLocator.getI18nManager();

		ChartLocator.getServiceManager().setChartManager(this);

	}

	public Service getService(DynObject parameters) throws ServiceException {

		return this.getServiceManager().createService(parameters);

	}

	public ChartProperties createProperties(String type) throws ServiceException {

		DynObject params = this.getServiceManager().createServiceParameters(type+"Properties");

		params.setDynValue("type", type);

		return (ChartProperties) params;

	}

	public ChartService createChart(ChartProperties properties) throws ServiceException {

		ChartService service = (ChartService)this.getService(properties);

		service.setChartDataSet(this.createChartDataSet());

		return service;

	}

	public ChartServiceManager getChartServiceManager() {

		return (ChartServiceManager)this.getServiceManager();

	}

	public GroupedCharts createGroupedCharts() {

		ChartProperties props;

		ChartService service;

		try {

			props = createProperties("GroupedCharts");

			service = createChart(props);

			if(service instanceof GroupedCharts){

				return (GroupedCharts)service;

			}

		} catch (ServiceException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	public ChartDataSet createChartDataSet() {

		return new DefaultChartDataSet();

	}

    public String getTranslation(String key) {

        return this.i18nmanager.getTranslation(key);

    }

}

package org.gvsig.chart.impl;

public class FeatureDataSet {

}

package org.gvsig.chart.impl.items;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Paint;

import java.awt.geom.Rectangle2D;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartManager;

import org.gvsig.chart.items.ChartLegendItem;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

import org.jfree.chart.block.BlockBorder;

import org.jfree.chart.title.LegendTitle;

import org.jfree.ui.HorizontalAlignment;

import org.jfree.ui.RectangleEdge;

import org.jfree.ui.VerticalAlignment;

public class DefaultChartLegendItem implements ChartLegendItem{

	public LegendTitle legend;

	private int x;

	private int y;

	private String horizontal;

	private String vertical;

	public DefaultChartLegendItem(){

		this.legend = null;

		this.horizontal = null;

		this.vertical = null;

		this.x = 0;

		this.y = 0;

	}

	public DefaultChartLegendItem(LegendTitle legendTitle){

		this.legend = legendTitle;

		if(legend.getBounds()!=null){

			this.x = ((Double)legend.getBounds().getX()).intValue();

			this.y = ((Double)legend.getBounds().getY()).intValue();

		}

	}

	public Object getLegendItem(){

		return legend;

	}

	public void setLegendItem(Object leg){

		if(leg instanceof LegendTitle)

			this.legend = (LegendTitle) leg;

	}

	public Paint getBackground() {

		return legend.getBackgroundPaint();

	}

	public void setBackground(Paint paint) {

		legend.setBackgroundPaint(paint);

	}

	public void draw(Graphics2D g2, Rectangle2D area) {

		if(horizontal == null && vertical == null){

			area.setRect(getXPosition(), getYPosition(), legend.getWidth(), legend.getHeight());

			legend.setFrame(new BlockBorder(1.0, 1.0, 1.0, 1.0));

			legend.draw(g2, area);

		}else{

			this.setPosition(horizontal, vertical);

		}

	}

	public Font getItemFont() {

		return legend.getItemFont();

	}

	public boolean isVisible() {

		return legend.isVisible();

	}

	public void setVisible(boolean isVisible) {

		legend.setVisible(isVisible);

	}

	public int getXPosition() {

		return this.x;

	}

	public int getYPosition() {

		return this.y;

	}

	public void setPosition(int x, int y){

		this.horizontal = null;

		this.vertical = null;

		this.x = x;

		this.y = y;

	}

	public void setPosition(String vertical, String horizontal){

		this.horizontal = horizontal;

		this.vertical = vertical;

		ChartManager swingManager = ChartLocator.getServiceManager().getChartManager();

		if(vertical == swingManager.getTranslation("LEFT")){

			legend.setHorizontalAlignment(HorizontalAlignment.LEFT);

		}

		if(vertical == swingManager.getTranslation("RIGHT")){

			legend.setHorizontalAlignment(HorizontalAlignment.RIGHT);

		}

		if(vertical == swingManager.getTranslation("CENTER")){

			if(horizontal == swingManager.getTranslation("TOP")||

					horizontal == swingManager.getTranslation("BOTTOM"))

				legend.setHorizontalAlignment(HorizontalAlignment.CENTER);

			if(horizontal == swingManager.getTranslation("LEFT") ||

					horizontal == swingManager.getTranslation("RIGHT"))

				legend.setVerticalAlignment(VerticalAlignment.CENTER);

		}

		if(vertical == swingManager.getTranslation("TOP")){

			legend.setVerticalAlignment(VerticalAlignment.TOP);

		}

		if(vertical == swingManager.getTranslation("BOTTOM")){

			legend.setVerticalAlignment(VerticalAlignment.BOTTOM);

		}

		if(horizontal == swingManager.getTranslation("TOP")){

			legend.setPosition(RectangleEdge.TOP);

		}

		if(horizontal == swingManager.getTranslation("BOTTOM")){

			legend.setPosition(RectangleEdge.BOTTOM);

		}

		if(horizontal == swingManager.getTranslation("LEFT")){

			legend.setPosition(RectangleEdge.LEFT);

		}

		if(horizontal == swingManager.getTranslation("RIGHT")){

			legend.setPosition(RectangleEdge.RIGHT);

		}

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		//state.set("LegendItem", this.getLegendItem());

		state.set("XCoordinate", this.x);

		state.set("YCoordinate", this.y);

		state.set("Horizontal", this.horizontal);

		state.set("Vertical", this.vertical);

	}

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		//this.setLegendItem(state.get("LegendItem"));

		this.setXCoordinate(state.getInt("XCoordinate"));

		this.setYCoordinate(state.getInt("YCoordinate"));

		this.setHorizontal(state.getString("Horizontal"));

		this.setVertical(state.getString("Vertical"));

	}

	private void setVertical(String string) {

		this.vertical = string;

	}

	private void setHorizontal(String string) {

		this.horizontal = string;

	}

	private void setYCoordinate(int double1) {

		this.y = double1;

	}

	private void setXCoordinate(int double1) {

		this.x = double1;

	}

	public static class RegisterPersistence implements Callable {

		public Object call() throws Exception {

			PersistenceManager manager = ToolsLocator.getPersistenceManager();

			if(manager.getDefinition("ChartLegendItem")==null ) {

				DynStruct definition = manager.addDefinition(

						DefaultChartLegendItem.class,

						"ChartLegendItem",

						"ChartLegendItem"+" Persistence definition (FIXME check keys type)",

						null, 

						null

				);

				// Values

				definition.addDynFieldInt("XCoordinate");

				definition.addDynFieldInt("YCoordinate");

				definition.addDynFieldString("Horizontal");

				definition.addDynFieldString("Vertical");

				//definition.addDynFieldObject("LegendItem").setClassOfValue(LegendTitle.class);

			}

			return Boolean.TRUE;

		}

	}

}

package org.gvsig.chart.impl.overlay;

import org.gvsig.chart.lib.spi.AbstractChartFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ServiceManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class OverlayChartFactory extends AbstractChartFactory {

	private static Logger logger = LoggerFactory.getLogger(OverlayChartFactory.class);

	public void initialize() {

	}

	@Override

	protected Service doCreate(DynObject parameters,

			ServiceManager serviceManager) throws ServiceException {

		return new OverlayChart(

				(OverlayChartProperties) parameters

				);

	}

	@Override

	protected DynClass createParametersDynClass() {

		DynObjectManager manager = ToolsLocator.getDynObjectManager();

		DynClass definition = manager.get("Chart","GroupedChartsProperties");

		if( definition==null ) {

			logger.info("Can't access to ChartProperties definition of OverlayChart");

		}

		return definition;

	}

	@Override

	public DynObject createParameters() {

		return new OverlayChartProperties();

	}

}

package org.gvsig.chart.impl.overlay;

import java.awt.Color;

import java.awt.Font;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.GroupedChartsProperties;

import org.gvsig.chart.impl.AbstractChart;

import org.gvsig.chart.impl.AbstractChartProperties;

import org.gvsig.chart.renderer.ChartSerieEntity;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

public class OverlayChartProperties extends AbstractChartProperties implements GroupedChartsProperties{

	List<ChartService> charts = new ArrayList<ChartService>();

	List<ChartSerieEntity> series = null;

	public OverlayChartProperties(){

		super("GroupedCharts");

		setChartType("GroupedCharts");

		setChartName("Gr?fico Compuesto.");

	}

	public static void registerDefinition(){

		DynObjectManager manager = ToolsLocator.getDynObjectManager();

		DynClass definition = manager.get("Chart","GroupedChartsProperties");

		if(definition == null){

			definition = manager.createDynClass("Chart", "GroupedChartsProperties",

					"Gr?fico que est? compuesto de otros gr?ficos que se pintar?n unos sobre otros.");

			definition.addDynFieldList("charts").setClassOfItems(ChartService.class);

			definition.addDynFieldList("series").setClassOfItems(ChartSerieEntity.class);;

			definition.addDynFieldString("MainTitle");

			definition.addDynFieldBoolean("isMainTitleVisible").setMandatory(true).setDefaultFieldValue(true);

			definition.addDynFieldObject("MainTitleFont").setClassOfValue(Font.class);

			definition.addDynFieldObject("MainTitleFontColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.BLACK);

			definition.addDynFieldObject("MainTitleBackgroundColor").setClassOfValue(Color.class);

			definition.addDynFieldObject("BackgroundColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.WHITE);

			definition.addDynFieldBoolean("BackgroundTransparent").setDefaultFieldValue(false);

			definition.addDynFieldString("NoChartMessageText");

			definition.addDynFieldBoolean("isChartVisibleIfNoData").setMandatory(true).setDefaultFieldValue(true);

			definition.addDynFieldString("NoDataMessageText");

			definition.addDynFieldObject("NoDataMessageFont").setClassOfValue(Font.class);

			definition.addDynFieldObject("NoDataMessageColor").setClassOfValue(Color.class);

			definition.addDynFieldObject("NoDataMessageBackgroundColor").setClassOfValue(Color.class);

			definition.addDynFieldInt("MainChartXPosition").setMandatory(true).setDefaultFieldValue(0);

			definition.addDynFieldInt("MainChartYPosition").setMandatory(true).setDefaultFieldValue(0);

			definition.addDynFieldInt("MainChartWidth").setMandatory(true).setDefaultFieldValue(0);

			definition.addDynFieldInt("MainChartHeight").setMandatory(true).setDefaultFieldValue(0);

			//Legend

			definition.addDynFieldBoolean("isMainLegendVisible").setMandatory(true).setDefaultFieldValue(true);

			definition.extend("Chart", "ChartProperties");

			manager.add(definition);

		}

	}

//	public static void registerPersistentDefinition(){

//		PersistenceManager manager = ToolsLocator.getPersistenceManager();

//		DynStruct definition = manager.getDefinition("GroupedChartsProperties");

//		if(definition == null){

//			definition = manager.addDefinition(

//					GroupedChartsProperties.class, 

//					"GroupedChartsProperties", 

//					"aqu? va la descripci?n", 

//					null, 

//					null);

//			

//			definition.addDynFieldArray("charts");

//			definition.addDynFieldArray("series");

//			

//			definition.addDynFieldString("MainTitle");

//			definition.addDynFieldBoolean("isMainTitleVisible").setMandatory(true).setDefaultFieldValue(true);

//			definition.addDynFieldObject("MainTitleFont").setClassOfValue(Font.class);

//			definition.addDynFieldObject("MainTitleFontColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.BLACK);

//			definition.addDynFieldObject("MainTitleBackgroundColor").setClassOfValue(Color.class);

//

//			definition.addDynFieldObject("BackgroundColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.WHITE);

//			definition.addDynFieldBoolean("BackgroundTransparent").setDefaultFieldValue(false);

//

//			definition.addDynFieldString("NoChartMessageText");

//			

//			definition.addDynFieldBoolean("isChartVisibleIfNoData").setMandatory(true).setDefaultFieldValue(true);

//

//			definition.addDynFieldString("NoDataMessageText");

//			definition.addDynFieldObject("NoDataMessageFont").setClassOfValue(Font.class);

//			definition.addDynFieldObject("NoDataMessageColor").setClassOfValue(Color.class);

//			definition.addDynFieldObject("NoDataMessageBackgroundColor").setClassOfValue(Color.class);

//

//			definition.addDynFieldInt("MainChartXPosition").setMandatory(true).setDefaultFieldValue(0);

//			definition.addDynFieldInt("MainChartYPosition").setMandatory(true).setDefaultFieldValue(0);

//			definition.addDynFieldInt("MainChartWidth").setMandatory(true).setDefaultFieldValue(0);

//			definition.addDynFieldInt("MainChartHeight").setMandatory(true).setDefaultFieldValue(0);

//			

//			//Legend

//			definition.addDynFieldBoolean("isMainLegendVisible").setMandatory(true).setDefaultFieldValue(true);

//			

//			definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,"ChartProperties");

//		}

//	}

	public List getCharts() {

		return  this.charts;

	}

	public void setCharts(List charts) {

		data.setDynValue("charts", charts);

		List<ChartService> services = new ArrayList<ChartService>();

		Iterator<ChartService> it = charts.iterator();

		while(it.hasNext()){

			ChartService cs = (ChartService)it.next();

			services.add(cs);

		}

		this.setChartServices(services);

	}

	public String getMainTitle() {

		return  (String) data.getDynValue("MainTitle");

	}

	public void setMainTitle(String charts) {

		data.setDynValue("MainTitle", charts);

	}

	public boolean isMainTitleVisible() {

		return  (Boolean) data.getDynValue("isMainTitleVisible");

	}

	public void setMainTitleVisibility(boolean charts) {

		data.setDynValue("isMainTitleVisible", charts);

	}

	public Font getMainTitleFont() {

		return  (Font) data.getDynValue("MainTitleFont");

	}

	public void setMainTitleFont(Font charts) {

		data.setDynValue("MainTitleFont", charts);

	}

	public Color getMainTitleFontColor(){

		return (Color) data.getDynValue("MainTitleFontColor");

	}

	public void setMainTitleFontColor(Color newColor) {

		data.setDynValue("MainTitleFontColor", newColor);

	}

	public Color getNoDataMessageBackgroundColor() {

		return (Color) data.getDynValue("NoDataMessageBackgroundColor");

	}

	public void setNoDataMessageBackgroundColor(Color newColor) {

		data.setDynValue("NoDataMessageBackgroundColor", newColor);

	}

	public String getNoDataMessageText() {

		return  (String) data.getDynValue("NoDataMessageText");

	}

	public void setNoDataMessageText(String text) {

		data.setDynValue("NoDataMessageText", text);

	}

	public String getNoChartMessageText() {

		return  (String) data.getDynValue("NoChartMessageText");

	}

	public void setNoChartMessageText(String text) {

		data.setDynValue("NoChartMessageText", text);

	}

	public boolean isChartVisibleIfNoData() {

		return  (Boolean) data.getDynValue("isChartVisibleIfNoData");

	}

	public void setIsChartVisibleIfNoData(boolean charts) {

		data.setDynValue("isChartVisibleIfNoData", charts);

	}

	public Font getNoDataMessageFont() {

		return  (Font) data.getDynValue("NoDataMessageFont");

	}

	public void setNoDataMessageFont(Font charts) {

		data.setDynValue("NoDataMessageFont", charts);

	}

	public Color getNoDataMessageColor(){

		return (Color) data.getDynValue("NoDataMessageColor");

	}

	public void setNoDataMessageColor(Color newColor) {

		data.setDynValue("NoDataMessageColor", newColor);

	}

	public Color getMainTitleBackgroundColor() {

		return (Color) data.getDynValue("MainTitleBackgroundColor");

	}

	public void setMainTitleBackgroundColor(Color newColor) {

		data.setDynValue("MainTitleBackgroundColor", newColor);

	}

	public Color getMainBackgroundColor() {

		return (Color) data.getDynValue("BackgroundColor");

	}

	public void setMainBackgroundColor(Color newColor) {

		data.setDynValue("BackgroundColor", newColor);

	}

	public boolean getMainBackgroundTransparency() {

		return (Boolean) data.getDynValue("BackgroundTransparent");

	}

	public void setMainBackgroundTransparency(boolean newColor) {

		data.setDynValue("BackgroundTransparent", newColor);

	}

	public int getMainChartXPosition() {

		return (Integer) data.getDynValue("MainChartXPosition");

	}

	public void setMainChartXPosition(int table) {

		data.setDynValue("MainChartXPosition", table);

	}

	public int getMainChartYPosition() {

		return (Integer) data.getDynValue("MainChartYPosition");

	}

	public void setMainChartYPosition(int table) {

		data.setDynValue("MainChartYPosition", table);

	}

	public int getMainChartWidth() {

		return (Integer) data.getDynValue("MainChartWidth");

	}

	public void setMainChartWidth(int table) {

		data.setDynValue("MainChartWidth", table);

	}

	public int getMainChartHeight() {

		return (Integer) data.getDynValue("MainChartHeight");

	}

	public void setMainChartHeight(int table) {

		data.setDynValue("MainChartHeight", table);

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		// Save parent properties

		super.saveToState(state);

		// Save own properties

		state.set("charts", this.getCharts());

		state.set("MainTitle", this.getMainTitle());

		state.set("isMainTitleVisible", this.isMainTitleVisible());

		state.set("MainTitleFont", this.getMainTitleFont());

		state.set("MainTitleFontColor", this.getMainTitleFontColor());

		state.set("MainTitleBackgroundColor", this.getMainTitleBackgroundColor());

		state.set("BackgroundColor", this.getMainBackgroundColor());

		state.set("BackgroundTransparent", this.getMainBackgroundTransparency());

		state.set("isChartVisibleIfNoData", this.isChartVisibleIfNoData());

		state.set("NoChartMessageText", this.getNoChartMessageText());

		state.set("NoDataMessageText", this.getNoDataMessageText());

		state.set("NoDataMessageFont", this.getNoDataMessageFont());

		state.set("NoDataMessageColor", this.getNoDataMessageColor());

		state.set("NoDataMessageBackgroundColor", this.getNoDataMessageBackgroundColor());

		state.set("MainChartXPosition", this.getMainChartXPosition());

		state.set("MainChartYPosition", this.getMainChartYPosition());

		state.set("MainChartWidth", this.getMainChartWidth());

		state.set("MainChartHeight", this.getMainChartHeight());

		state.set("LegendOrientation", this.getLegendOrientation());

		state.set("LegendPosition", this.getLegendPosition());

		state.set("isMainLegendVisible", this.getIsLegendVisible());

	}

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		// Set parent properties

		super.loadFromState(state);

		// Set own properties

		this.setCharts(state.getList("charts"));

		this.setMainTitle(state.getString("MainTitle"));

		this.setMainTitleVisibility(state.getBoolean("isMainTitleVisible"));

		this.setMainTitleFont((Font)state.get("MainTitleFont"));

		this.setMainTitleFontColor((Color)(state.get("MainTitleFontColor")));

		this.setMainTitleBackgroundColor((Color)(state.get("MainTitleBackgroundColor")));

		this.setMainBackgroundColor((Color)(state.get("BackgroundColor")));

		this.setMainBackgroundTransparency(state.getBoolean("BackgroundTransparent"));

		this.setIsChartVisibleIfNoData(state.getBoolean("isChartVisibleIfNoData"));

		this.setNoChartMessageText(state.getString("NoChartMessageText"));

		this.setNoDataMessageText(state.getString("NoDataMessageText"));

		this.setNoDataMessageFont((Font)state.get("NoDataMessageFont"));

		this.setNoDataMessageColor((Color)state.get("NoDataMessageColor"));

		this.setNoDataMessageBackgroundColor((Color)state.get("NoDataMessageBackgroundColor"));

		this.setMainChartXPosition(state.getInt("MainChartXPosition"));

		this.setMainChartYPosition(state.getInt("MainChartYPosition"));

		this.setMainChartWidth(state.getInt("MainChartWidth"));

		this.setMainChartHeight(state.getInt("MainChartHeight"));

		this.setLegendOrientation(state.getString("LegendOrientation"));

		this.setLegendPosition(state.getString("LegendPosition"));

		this.setIsLegendVisible(state.getBoolean("isMainLegendVisible"));

	}

	public GroupedChartsProperties clone(){

		OverlayChartProperties ovProps = 

			(OverlayChartProperties) ChartLocator.getServiceManager().getChartManager().createGroupedCharts().getGroupedChartsProperties();

		ovProps.setMainBackgroundColor(this.getMainBackgroundColor());

		ovProps.setMainBackgroundTransparency(this.getMainBackgroundTransparency());

		ovProps.setMainChartXPosition(this.getMainChartXPosition());

		ovProps.setMainChartYPosition(this.getMainChartYPosition());

		ovProps.setMainChartWidth(this.getMainChartWidth());

		ovProps.setMainChartHeight(this.getMainChartHeight());

		ovProps.setHasLegendCoordinates(this.getHasLegendCoordinates());

		ovProps.setLegendOrientation(this.getLegendOrientation());

		ovProps.setLegendPosition(this.getLegendPosition());

		ovProps.setLegendXCoordinate(this.getLegendXCoordinate());

		ovProps.setLegendYCoordinate(this.getLegendYCoordinate());

		ovProps.setLegendTitleText(this.getLegendTitleText());

		ovProps.setLegendTitleFont(this.getLegendTitleFont());

		ovProps.setLegendTitleIsVisible(this.getLegendTitleIsVisible());

		ovProps.setMainTitle(this.getMainTitle());

		ovProps.setMainTitleVisibility(this.isMainTitleVisible());

		ovProps.setMainTitleFont(this.getMainTitleFont());

		ovProps.setMainTitleFontColor(this.getMainTitleFontColor());

		ovProps.setMainTitleBackgroundColor(this.getMainTitleBackgroundColor());

		List services = new ArrayList();

		Iterator<ChartService> it = this.getChartServices().iterator();

		while(it.hasNext()){

			ChartService cs = (ChartService)it.next();

			services.add(cs.clone());

		}

		ovProps.setChartServices(services);

		List<ChartSerieEntity> colors = new ArrayList<ChartSerieEntity>();

		Iterator<ChartSerieEntity> it2 = this.getSeries().iterator();

		while(it2.hasNext()){

			ChartSerieEntity cs = (ChartSerieEntity)it2.next();

			colors.add(cs.clone());

		}

		ovProps.setSeries(colors);

		return ovProps;

	}

	public List getChartServices() {

		return this.charts;

	}

	public void setChartServices(List<ChartService> chartServ) {

		this.charts = chartServ;

	}

	public List<ChartSerieEntity> getSeries() {

		this.series = (List<ChartSerieEntity>) data.getDynValue("series");

		if(this.series == null){

			this.series = new ArrayList<ChartSerieEntity>();

			setSeries(this.series);

		}

		return this.series;

	}

	public void setSeries(List<ChartSerieEntity> colors) {

		data.setDynValue("series", colors);

	}

	public static class RegisterPersistence implements Callable {

		public Object call() throws Exception {

			PersistenceManager manager = ToolsLocator.getPersistenceManager();

			if(manager.getDefinition("GroupedChartsProperties")==null ) {

				DynStruct definition = manager.addDefinition(

						OverlayChartProperties.class,

						"GroupedChartsProperties",

						"GroupedChartsProperties"+" Persistence definition (FIXME check keys type)",

						null, 

						null

				);

//				// Extend the Classified Vector Legend base definition

				definition.extend(manager.getDefinition("ChartProperties"));

				// Values

				definition.addDynFieldList("charts").setClassOfItems(ChartService.class);

				definition.addDynFieldArray("series").setClassOfItems(ChartSerieEntity.class);

				definition.addDynFieldString("MainTitle");

				definition.addDynFieldBoolean("isMainTitleVisible").setDefaultFieldValue(true);

				definition.addDynFieldObject("MainTitleFont").setClassOfValue(Font.class);

				definition.addDynFieldObject("MainTitleFontColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.BLACK);

				definition.addDynFieldObject("MainTitleBackgroundColor").setClassOfValue(Color.class);

				definition.addDynFieldObject("BackgroundColor").setClassOfValue(Color.class).setDefaultFieldValue(Color.WHITE);

				definition.addDynFieldBoolean("BackgroundTransparent").setDefaultFieldValue(false);

				definition.addDynFieldString("NoChartMessageText");

				definition.addDynFieldBoolean("isChartVisibleIfNoData").setDefaultFieldValue(true);

				definition.addDynFieldString("NoDataMessageText");

				definition.addDynFieldObject("NoDataMessageFont").setClassOfValue(Font.class);

				definition.addDynFieldObject("NoDataMessageColor").setClassOfValue(Color.class);

				definition.addDynFieldObject("NoDataMessageBackgroundColor").setClassOfValue(Color.class);

				definition.addDynFieldInt("MainChartXPosition").setDefaultFieldValue(0);

				definition.addDynFieldInt("MainChartYPosition").setDefaultFieldValue(0);

				definition.addDynFieldInt("MainChartWidth").setDefaultFieldValue(0);

				definition.addDynFieldInt("MainChartHeight").setDefaultFieldValue(0);

				//Legend

				definition.addDynFieldBoolean("isMainLegendVisible").setDefaultFieldValue(true);

			}

			return Boolean.TRUE;

		}

	}

}

package org.gvsig.chart.impl.overlay;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Paint;

import java.awt.Rectangle;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.imageio.ImageIO;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartProperties;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.GroupedCharts;

import org.gvsig.chart.GroupedChartsProperties;

import org.gvsig.chart.axis.CategoryAxis;

import org.gvsig.chart.axis.ChartAxis;

import org.gvsig.chart.axis.ValueAxis;

import org.gvsig.chart.impl.AbstractChart;

import org.gvsig.chart.impl.axis.ChartNumberAxis;

import org.gvsig.chart.impl.renderer.DefaultChartRenderer;

import org.gvsig.chart.impl.renderer.DefaultChartSerieEntity;

import org.gvsig.chart.model.ChartDataSet;

import org.gvsig.chart.renderer.ChartRenderer;

import org.gvsig.chart.renderer.ChartSerieEntity;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.service.spi.ProviderManager;

import org.gvsig.tools.util.Callable;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.LegendItemCollection;

import org.jfree.chart.LegendItemSource;

import org.jfree.chart.block.BlockBorder;

import org.jfree.chart.block.BlockContainer;

import org.jfree.chart.block.BorderArrangement;

import org.jfree.chart.block.LabelBlock;

import org.jfree.chart.plot.CategoryPlot;

import org.jfree.chart.plot.Plot;

import org.jfree.chart.plot.XYPlot;

import org.jfree.chart.renderer.AbstractRenderer;

import org.jfree.chart.title.LegendTitle;

import org.jfree.chart.title.TextTitle;

import org.jfree.chart.title.Title;

import org.jfree.ui.RectangleEdge;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.lowagie.text.Document;

import com.lowagie.text.PageSize;

import com.lowagie.text.pdf.DefaultFontMapper;

import com.lowagie.text.pdf.PdfContentByte;

import com.lowagie.text.pdf.PdfTemplate;

import com.lowagie.text.pdf.PdfWriter;

public class OverlayChart extends AbstractChart implements GroupedCharts, Observer {

	private static final Logger LOG = LoggerFactory

			.getLogger(OverlayChart.class);

	String type = "GroupedCharts";

	private boolean restored = false;

	private Font scaledFont = null;

	public OverlayChart(){

		this((OverlayChartProperties) ChartLocator.getServiceManager().getChartManager().createGroupedCharts().getGroupedChartsProperties());

	}

	public OverlayChart(OverlayChartProperties chartProps) {

		this.setChartProperties(chartProps);

	}

	public Manager getManager() {

		return null;

	}

	protected ProviderManager getProviderManager() {

		return null;

	}

	@Override

	protected JFreeChart getInternalChart() {

		if (getChartServices().size() > 0) {

			chart = (JFreeChart) getChartServices().get(0).getInnerChart();

			return chart;

		}

		return null;

	}

	protected JFreeChart getInternalChart(int i) {

		if (getChartServices().size() > i) {

			chart = (JFreeChart) getChartServices().get(i).getInnerChart();

			return chart;

		}

		return null;

	}

	@Override

	public void scaleFonts(double ratio) {

		if (getChartServices().size() > 0) {

			for (ChartService cs : getChartServices()) {

				cs.scaleFonts(ratio);

				if(!cs.getDomainAxis().isEmpty()){

					this.scaledFont =  cs.getDomainAxis().get(0).getLabelFont();

				}

			}

		}

	}

	public void setAxisVisibles(boolean visible) {

		if (getChartServices().size() > 0) {

			for (ChartService cs : getChartServices()) {

				if(cs.getDomainAxis() != null){

					Iterator it = cs.getDomainAxis().iterator();

					while(it.hasNext()){

						ChartAxis axis = (ChartAxis)it.next();

						axis.setIsChartAxisTitleVisible(visible);

					}

				}

				if(cs.getRangeAxis() != null){

					Iterator it = cs.getRangeAxis().iterator();

					while(it.hasNext()){

						ChartAxis axis = (ChartAxis)it.next();

						axis.setIsChartAxisTitleVisible(visible);

					}

				}

			}

		}

	}

	public void draw(Graphics2D g, Rectangle r) {

		LOG.info("Providers: " + this.type);

		if(this.restored){

			notifyObservers(this);

			this.restored = false;

		}

		OverlayChartProperties props = (OverlayChartProperties) getChartProperties();

		boolean isAnyGraphPainted = false;

		this.getSeries().clear();

		g.clearRect(r.x, r.y, r.width, r.height);

		if(!props.getHasPlotDefaultSize()){

			Rectangle customRec = new Rectangle(

					props.getMainChartXPosition(), 

					props.getMainChartYPosition(), 

					props.getMainChartWidth(), 

					props.getMainChartHeight());

			Rectangle resultRec = (Rectangle) customRec.createIntersection(r);

			r = resultRec;

		}

		// Pintamos el fondo

		if(props.getMainBackgroundTransparency()){

			g.clearRect(r.x, r.y, r.width, r.height);

		}else{

			if(props.getMainBackgroundColor() != null){

				g.setPaint(this.getGroupedChartsProperties().getMainBackgroundColor());

			}else{

				g.setPaint(Color.WHITE);

			}

			g.fillRect(r.x, r.y, r.width, r.height);

		}

		// Iteramos por los charts

		int firstChart = 0;

		if(getChartServices().size() > 0){

			// Cargamos todos los ejes

			this.rangeAxis = new ArrayList<ValueAxis>();

			this.domainAxis = new ArrayList<ChartAxis>();

			for (int i = 0; i < getChartServices().size(); i++) {

				ChartService cs = getChartServices().get(i);

				cs.getChartProperties().setIsChartVisibleIfNoData(

						this.getGroupedChartsProperties().isChartVisibleIfNoData());

				cs.getChartProperties().setNoDataMessageText(

						this.getGroupedChartsProperties().getNoDataMessageText());

				Iterator<ChartAxis> it = cs.getDomainAxis().iterator();

				while(it.hasNext()){

					ChartAxis axis =  (ChartAxis)it.next();

					if(axis.isAxisShared()){

						ChartService cs2 = axis.getSharedAxis().getChartService();

						if(cs2 != null){

							cs.getChartDataSet().combine(cs2.getChartDataSet());

							cs2.getChartDataSet().combine(cs.getChartDataSet());

						}

					}

				}

//				

//				Iterator<ValueAxis> it2 = cs.getRangeAxis().iterator();

//				while(it2.hasNext()){

//					ValueAxis axis =  (ValueAxis)it2.next();

//					((ChartNumberAxis)axis).setAssociatedAxis(false);

//				}

			}

			for (int i = 0; i < getChartServices().size(); i++) {

				ChartService cs = getChartServices().get(i);

				// Obtenemos los ejes

				if(cs.isVisible() && (cs.hasDomainAxis() || cs.hasRangeAxis())){

					if(cs.hasRangeAxis()){

						// Si es un eje compartido

						if(!cs.getRangeAxis().isEmpty() &&

								cs.getRangeAxis().get(0).isAxisShared() && 

								cs.getRangeAxis().get(0).getSharedAxis().isVisible()){

							int index = this.getRangeAxis().indexOf(cs.getRangeAxis().get(0).getSharedAxis());

							// Buscamos el eje con el que comparte, para combinarlo con ?l (debe ser anterior a ?l)

							if(index != -1){

								ChartAxis chartAxis = combinarAxis(this.getRangeAxis().get(index), cs.getRangeAxis().get(0));

								if(chartAxis instanceof ValueAxis){

									((ChartNumberAxis)this.getRangeAxis().get(index)).setAssociatedAxis(true);

									this.getRangeAxis().set(index, this.getRangeAxis().get(index));

									cs.setRangeAxis((ValueAxis) chartAxis);

									cs.getRangeAxis().get(0).setRange(((ValueAxis) chartAxis).getMin(), ((ValueAxis) chartAxis).getMax());

									cs.getRangeAxis().get(0).setVisible(false);

								}

							}

						// Si no es compartido

						}else{

							if(!cs.getRangeAxis().isEmpty())

								cs.getRangeAxis().get(0).setAutoRange(true);

								this.getRangeAxis().add(cs.getRangeAxis().get(0));

						}

					}

					if(cs.hasDomainAxis()){

						if(!cs.getDomainAxis().isEmpty() &&

								cs.getDomainAxis().get(0).isAxisShared() && 

								cs.getDomainAxis().get(0).getSharedAxis().isVisible()){

							int index = this.getDomainAxis().indexOf(cs.getDomainAxis().get(0).getSharedAxis());

							if(index != -1){

								ChartAxis chartAxis = combinarAxis(this.getDomainAxis().get(index), cs.getDomainAxis().get(0));

//								if(chartAxis instanceof ChartCategoryAxis){

//									this.getDomainAxis().set(index, this.getDomainAxis().get(index));

//									cs.setDomainAxis((ChartAxis) chartAxis);

//									cs.getDomainAxis().get(0).setVisible(false);

//								}

							}

						}else{

							if (cs.getDomainAxis().size() > 0) {

								cs.getDomainAxis().get(0).setCategoryLabelPositions(cs.getChartProperties().getDomainAxisPosition());

								this.getDomainAxis().add(cs.getDomainAxis().get(0));

							}

						}

					}

				}

			}

			for (int i = 0; i < getChartServices().size(); i++) {

				ChartService cs = getChartServices().get(i);

				// Inicializamos los ejes de cada chat

				cs.update();

				// Unificamos leyendas

				if(cs.isVisible() && cs.getChartProperties().getIsLegendVisible()){

					this.getSeries().addAll(cs.getChartDataSet().getSeries());

				}

			}

			// Pintamos usando los ejes creados

			firstChart = 0;

			for (int i = 0; i < getChartServices().size(); i++) {

				ChartService cs = getChartServices().get(i);

				if(cs.isVisible()){

					if (firstChart == 0) {

						boolean isFirstChartLegendVisible = cs.getChartProperties().getIsLegendVisible();

						cs.getChartProperties().setIsLegendVisible(true);

						if(props.isMainTitleVisible()){

							String titleText = props.getMainTitle();

							Font titleFont = props.getMainTitleFont();

							if(titleText != null){

								TextTitle title = null;

								if(titleFont != null)

									title = new TextTitle(titleText, titleFont);

								else

									title = new TextTitle(titleText);

								if(props.getMainTitleFontColor()!=null)

									title.setPaint(props.getMainTitleFontColor());

								if(props.getMainTitleBackgroundColor()!=null)

									title.setBackgroundPaint(props.getMainTitleBackgroundColor());

								this.getInternalChart().setTitle(title);

							}

						}else{

							this.getInternalChart().setTitle((TextTitle)null);

						}

						if(cs.hasDomainAxis()){

							cs.setDomainAxis(this.getDomainAxis());

						}

						if(cs.hasRangeAxis()){

							cs.setRangeAxis(this.getRangeAxis());

						}

						cs.setBackgroundPaint(null);

						((JFreeChart)cs.getInnerChart()).getPlot().setBackgroundPaint(null);

						cs.setBackgroundPaint(0.0f);

						cs.getChartProperties().setIsMandatoryChart(true);

						if(!this.getGroupedChartsProperties().getIsLegendVisible()){

							cs.getChartProperties().setIsLegendVisible(false);

						}

						((JFreeChart)cs.getInnerChart()).removeLegend();

							LegendTitle legend = new LegendTitle(new CustomLegendItemSource());

							legend.setPosition(RectangleEdge.BOTTOM);

	//						LegendTitle legend = createLegend(cs, g, r, null);

							setLegendParameters(cs);

							((JFreeChart)cs.getInnerChart()).addLegend(legend);

						cs.draw(g, r);

						Rectangle2D plotArea = cs.getChartRenderingInfo().getPlotArea();

						this.getChartRenderingInfo().setChartArea(cs.getChartRenderingInfo().getChartArea());

						this.getChartRenderingInfo().setPlotArea(plotArea);

						if(plotArea!=null){

							props.setPlotXPosition((int) plotArea.getMinX());

							props.setPlotYPosition((int) plotArea.getMinY());

							props.setPlotWidth((int) plotArea.getWidth());

							props.setPlotHeight((int) plotArea.getHeight());

						}

						cs.getChartProperties().setIsLegendVisible(isFirstChartLegendVisible);

					} else {

						cs.setBackgroundPaint(cs.getChartProperties().getPlotBackgroundColor());

						((JFreeChart)cs.getInnerChart()).getPlot().setBackgroundPaint(cs.getChartProperties().getPlotBackgroundColor());

						cs.setBackgroundPaint(cs.getChartProperties().getPlotBackgroundAlpha());

						cs.getChartProperties().setIsMandatoryChart(false);

						cs.getChartRenderingInfo().setPlotArea(this.getChartRenderingInfo().getPlotArea());

						cs.draw(g, (Rectangle) this.getChartRenderingInfo().getPlotArea());

					}

					if(cs.canBeOverlayed()){

						firstChart++;

					}else{

						isAnyGraphPainted = true;

					}

				}

			}

		}

		if ((getChartServices() == null) || (getChartServices().size() == 0)  || (firstChart==0 && !isAnyGraphPainted)) {

			if(this.getGroupedChartsProperties().getNoDataMessageColor() != null){