gvSIG tools: basic charts

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

				<include>org.gvsig:org.gvsig.chart.lib.api</include>

				<include>org.gvsig:org.gvsig.chart.swing.api</include>

				<include>org.gvsig:org.gvsig.chart.lib.base</include>

				<include>org.gvsig:org.gvsig.chart.swing.base</include>

				<include>org.gvsig:org.gvsig.chart.lib.impl</include>

				<include>org.gvsig:org.gvsig.chart.swing.impl</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.app.project.documents.chart;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.DocumentManager;

import org.gvsig.app.project.documents.chart.events.ChartPropertiesChangeEvent;

import org.gvsig.app.project.documents.chart.events.ChartPropertiesChangeListener;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartProperties;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.GroupedCharts;

import org.gvsig.chart.model.ChartDataSet;

import org.gvsig.chart.model.variables.RequiredField;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

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.util.Callable;

public class ChartDocument extends AbstractDocument implements Document,

		Observer {

	/**

	 * 

	 */

	private static final long serialVersionUID = 1421212389948622432L;

	private GroupedCharts overlayChart = null;

	private ChartDocumentManager documentManager;

	private FeatureStore store;

	private FeatureQuery query;

	// Create the listener list

	protected javax.swing.event.EventListenerList listenerList = new javax.swing.event.EventListenerList();

	private boolean restored = false;

	/**

	 * documentContext will have information about UsedFields and other

	 * information that may be needed. UsedFields have information about the

	 * table and fields from we will get information

	 */

	// private ArrayList<String> categoryFields;

	// private String chartType;

	// public ArrayList<String> getCategoryFields() {

	// return categoryFields;

	// }

	//

	// public String getChartType() {

	// return chartType;

	// }

	// public ArrayList<String> getSeriesFields() {

	// return seriesFields;

	// }

	// private ArrayList<String> seriesFields;

	public ChartDocument() {

		this(new ChartDocumentManager());

		this.restored  = true;

	}

	public ChartDocument(DocumentManager factory) {

		super(factory);

		this.documentManager = (ChartDocumentManager) factory;

		this.store = null;

		this.query = null;

		this.overlayChart = ChartLocator.getServiceManager().getChartManager()

				.createGroupedCharts();

	}

	public ChartDocument(DocumentManager factory, FeatureStore store) {

		this(factory);

		setStore(store);

	}

	public FeatureStore getStore() {

		return store;

	}

	public void setStore(FeatureStore store) {

		if (this.store != null) {

			throw new UnsupportedOperationException(

					"can't set store. store already set.");

		}

		this.store = store;

		this.store.addObserver(this);

		this.query = null; // setQuery(store.createFeatureQuery());

	}

	public void update(Observable observable, Object notification) {

//		if (this.store.equals(observable)) {

		if (observable instanceof GroupedCharts){

			if(this.restored){

				refreshGroupedChartsData();

				this.overlayChart.deleteObserver(this);

				this.restored = false;

			}

		}

		if (observable instanceof FeatureSelection) {

			boolean bNeedUpdate = false;

			for (ChartService cs: overlayChart.getChartServices()) {

				if (cs.getChartProperties().getUseSelectedFeatures()) {

					bNeedUpdate = true;

					try {

						refreshChartServiceData(cs);

					} catch (DataException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

				}

			}

			if (bNeedUpdate) {

				fireChartPropertiesChangeEvent(null);

			}

		}

			if (notification instanceof FeatureStoreNotification) {

				FeatureStoreNotification event = (FeatureStoreNotification) notification;

				String type = event.getType();

				// If the selection has changed, repaint the table to show the

				// new

				// selected rows

				if (FeatureStoreNotification.SELECTION_CHANGE.equals(type)) {

					// TODO: ENVIAR UN EVENTO QUE NO SEA NULL?

					fireChartPropertiesChangeEvent(null);

				}

				if (type.equals(FeatureStoreNotification.TRANSFORM_CHANGE)

						|| type.equals(FeatureStoreNotification.RESOURCE_CHANGED)) {

					this.query = null;

				}

			}

//		}

	}

	public void refreshGroupedChartsData() {

		List<ChartService> chartServices = this.overlayChart.getChartServices();

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

			try {

				ChartService cs = chartServices.get(i);

				refreshChartServiceData(cs);

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		super.loadFromState(state);

		// this.store = (FeatureStore) state.get("store");

		// this.query = (FeatureQuery) state.get("query");

		try {

			setChartService((GroupedCharts)state.get("GroupedCharts"));

		} catch (Exception e) {

			e.printStackTrace();

		}

	}

	public void refreshChartServiceData(ChartService cs) throws DataException{

		ApplicationManager appManager = ApplicationLocator.getManager();

		Project project = appManager.getCurrentProject();

		ChartProperties cp = cs.getChartProperties();

		FeatureSet fs;

		String tableName = cs.getChartProperties().getChartTableName();

		if(tableName != null){

			TableDocument table = (TableDocument) project.getDocument(

					tableName, TableManager.TYPENAME);

			if (table == null) {

				throw new RuntimeException("No se encuentra la tabla "

						+ tableName);

			}

			ChartDataSet dataSet = cs.getChartDataSet();

			FeatureSelection fsel = table.getStore().getFeatureSelection();

			fs = table.getStore().getFeatureSet(); 

			DisposableIterator it = null;

			if (cp.getUseSelectedFeatures()) {

				it = fsel.fastIterator();

			}

			else {

				it = fs.fastIterator();

			}

			int[] fieldIDs = new int[cp.getRequiredFields().size()];

			ArrayList[] data = new ArrayList[cp.getRequiredFields().size()];

			// Buscamos los ID de los campos que vamos a usar.

			for (int j = 0; j < cp.getRequiredFields().size(); j++) {

				RequiredField rq = cp.getRequiredFields().get(j);

				if (rq.isOptional()) {

					if (fs.getDefaultFeatureType()

							.getAttributeDescriptor(rq.getValue()) == null)

						fieldIDs[j] = -1;

					else{

						fieldIDs[j] = fs.getDefaultFeatureType()

							.getAttributeDescriptor(rq.getValue()).getIndex();

					}

				}

				else {

					fieldIDs[j] = fs.getDefaultFeatureType()

							.getAttributeDescriptor(rq.getValue()).getIndex();

				}

				ArrayList<Object> aux = new ArrayList<Object>();

				data[j] = aux;

			}

			// if onlyRecordsSelected is set, we should iterate by selected features only

			while (it.hasNext()) {

				Feature f = (Feature) it.next();

				for (int j = 0; j < fieldIDs.length; j++) {

					if (fieldIDs[j] != -1)

						data[j].add(f.get(fieldIDs[j]));

				}

			}

			for (int j = 0; j < fieldIDs.length; j++) {

				RequiredField rq = cp.getRequiredFields().get(j);

				if (fieldIDs[j] != -1)

					dataSet.addData(rq.getName(),

						data[j]);

			}

			it.dispose();

			cs.setChartDataSet(dataSet);

			cs.update();

			cs.loadSavedChartLegendItems();

		}

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

		state.set("GroupedCharts", this.getChartService());

	}

	public static class RegisterPersistence implements Callable {

		public Object call() throws Exception {

			PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

				DynStruct definition = manager

						.addDefinition(

								ChartDocument.class,

								"ChartDocumentPersistence",

								"ChartDocumentPersistence"

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

								null, null);

				// // Extend the Classified Vector Legend base definition

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

				// Values

				definition.addDynFieldObject("GroupedCharts").setClassOfValue(GroupedCharts.class);

			}

			return Boolean.TRUE;

		}

	}

	public IWindow getMainWindow() {

		return this.getFactory().getMainWindow(this);

	}

	public void setChartService(GroupedCharts chartService) {

		this.overlayChart = chartService;

		// repasamos las tablas y nos ponemos como escucha

		ApplicationManager appManager = ApplicationLocator.getManager();

		final Project project = appManager.getCurrentProject();

		List<Document> tableDocuments = project

				.getDocuments(TableManager.TYPENAME);

		TableDocument[] pts = tableDocuments

				.toArray(new TableDocument[tableDocuments.size()]);

		for (TableDocument t : pts) {

			try {

				FeatureSelection featSelection = t.getFeatureStoreModel()

						.getFeatureStore().getFeatureSelection();

				featSelection.deleteObserver(this);

				for (ChartService cs : chartService.getChartServices()) {

					if (cs.getChartProperties().getChartTableName()

							.equals(t.getName())) {

						featSelection.addObserver(this);

					}

				}

			} catch (DataException e) {

				e.printStackTrace();

			}

		}

		fireChartPropertiesChangeEvent(null);

		if(this.restored){

			this.overlayChart.addObserver(this);

		}

	}

	public GroupedCharts getChartService() {

		return overlayChart;

	}

	/**

	 * Manejador de eventos cuando hay un cambio en ChartProperties

	 */

	public void addChartPropertiesChangeEventListener(

			ChartPropertiesChangeListener listener) {

		listenerList.add(ChartPropertiesChangeListener.class, listener);

	}

	public void removeChartPropertiesChangeEventListener(

			ChartPropertiesChangeListener listener) {

		listenerList.remove(ChartPropertiesChangeListener.class, listener);

	}

	void fireChartPropertiesChangeEvent(ChartPropertiesChangeEvent evt) {

		Object[] listeners = listenerList.getListenerList();

		// Each listener occupies two elements - the first is the listener class

		// and the second is the listener instance

		for (int i = 0; i < listeners.length; i += 2) {

			if (listeners[i] == ChartPropertiesChangeListener.class) {

				((ChartPropertiesChangeListener) listeners[i + 1])

						.chartPropertiesChange(evt);

			}

		}

	}

	public ChartDocumentManager getDocumentManager() {

		return documentManager;

	}

}

package org.gvsig.app.project.documents.chart.events;

import java.util.EventListener;

public interface ChartPropertiesChangeListener extends EventListener {

    public void chartPropertiesChange(ChartPropertiesChangeEvent evt);

}

package org.gvsig.app.project.documents.chart.events;

import java.util.EventObject;

public class ChartPropertiesChangeEvent extends EventObject {

    /**

	 * 

	 */

	private static final long serialVersionUID = -1974434668957358782L;

	public ChartPropertiesChangeEvent(Object source) {

        super(source);

    }

}

package org.gvsig.app.project.documents.chart.gui;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.swing.editors.EditorChartServicePanel;

import org.gvsig.chart.swing.editors.panels.EditorChartPropertiesPanel;

public class EditorChartServiceJDialog  {

    public static ChartService showDialog(String title, EditorChartServicePanel editorPanel) {

    	DefaultEditorChartServiceJDialog dlg = new DefaultEditorChartServiceJDialog(title, true, editorPanel);

    	if(dlg.getMainPanel().isCancelled()) {

    		dlg.setVisible(false);

    		return null;

    	}

    	return dlg.getChartService();

    }

    public static ChartService showDialog(String title, EditorChartPropertiesPanel editorPanel) {

    	DefaultEditorChartPropertiesJDialog dlg = new DefaultEditorChartPropertiesJDialog(title, true, editorPanel);

    	if(dlg.getMainPanel().isCancelled()) {

    		dlg.setVisible(false);

    		return null;

    	}

    	return dlg.getChartService();

    }

}

package org.gvsig.app.project.documents.chart.gui;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import javax.swing.JDialog;

import org.gvsig.app.gui.utils.FontChooser;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.swing.ChartSwingLocator;

import org.gvsig.chart.swing.ChartSwingManager;

import org.gvsig.chart.swing.editors.panels.EditorChartPropertiesPanel;

import org.gvsig.chart.swing.editors.panels.format.chartarea.ChartServiceFormatLegendPanel;

import org.gvsig.chart.swing.editors.panels.format.chartarea.ChartServiceFormatTitlePanel;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

/**

 * A dialog for choosing a font from the available system fonts.

 *

 * @author Jos? Bad?a

 */

public class DefaultEditorChartPropertiesJDialog  extends JDialog implements Observer{

    /**

	 * 

	 */

	private static final long serialVersionUID = 822457766380562414L;

    private EditorChartPropertiesPanel panel;

	private ChartSwingManager swingManager;

    /**

     * Standard constructor - builds a font chooser dialog owned by another dialog.

     *

     * @param owner  the dialog that 'owns' this dialog.

     * @param title  the title for the dialog.

     * @param modal  a boolean that indicates whether or not the dialog is modal.

     * @param font  the initial font displayed.

     */

    public DefaultEditorChartPropertiesJDialog(String title, boolean modal, EditorChartPropertiesPanel panel) {

        super();

        this.panel = panel;

        this.panel.addObserver(this);

    	swingManager = ChartSwingLocator.getSwingManager().getChartSwingManager();

        setTitle(title);

        setContentPane(panel.getComponent());

        panel.getComponent().addComponentListener(new ComponentListener() {

			public void componentShown(ComponentEvent arg0) {

				// TODO Auto-generated method stub

			}

			public void componentResized(ComponentEvent arg0) {

				// TODO Auto-generated method stub

			}

			public void componentMoved(ComponentEvent arg0) {

				// TODO Auto-generated method stub

			}

			public void componentHidden(ComponentEvent arg0) {

				DefaultEditorChartPropertiesJDialog.this.dispose();

			}

		});

        getContentPane().setVisible(true);

        setPreferredSize(new Dimension(850,500));

        setModal(true);

        pack();

        setSize(700, 500);

        setVisible(true);

    }

    public ChartService getChartService(){

    	return panel.getChartService();

    }

	public EditorChartPropertiesPanel getMainPanel() {

		return this.panel;

	}

	public void update(Observable observable, Object notification) {

		if(observable instanceof EditorChartPropertiesPanel){

			if(observable instanceof ChartServiceFormatTitlePanel){

				ChartServiceFormatTitlePanel titlePanel = (ChartServiceFormatTitlePanel)observable;

				Font newFont = null;

				newFont = FontChooser.showDialog(this.swingManager.getTranslation("Pick_Color"), titlePanel.getTitleFont());

				if (newFont == null) {

					return;

				}

				titlePanel.setTitleFont(newFont);

			}

			if(observable instanceof ChartServiceFormatLegendPanel){

				ChartServiceFormatLegendPanel titlePanel = (ChartServiceFormatLegendPanel)observable;

				Font newFont = null;

				newFont = FontChooser.showDialog(this.swingManager.getTranslation("Pick_Color"), titlePanel.getLegendTitleFont());

				if (newFont == null) {

					return;

				}

				titlePanel.setLegendTitleFont(newFont);

			}

		}

	}

}

package org.gvsig.app.project.documents.chart.gui;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import javax.swing.JButton;

import javax.swing.JDialog;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.chart.ChartDocument;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.chart.ChartProperties;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.GroupedCharts;

import org.gvsig.chart.model.ChartDataSet;

import org.gvsig.chart.model.variables.RequiredField;

import org.gvsig.chart.swing.ChartSwingLocator;

import org.gvsig.chart.swing.ChartSwingManager;

import org.gvsig.chart.swing.editors.EditorChartServicePanel;

import org.gvsig.chart.swing.editors.EditorGroupedChartPanel;

import org.gvsig.chart.swing.editors.panels.ChartServiceDataPanel;

import org.gvsig.chart.swing.editors.panels.EditorChartPropertiesPanel;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

public class DefaultEditorGroupedChartIWindow extends JPanel implements IWindow, Observer {

	/**

	 * 

	 */

	private static final long serialVersionUID = -412071853707015402L;

	private static final long ROW_LIMIT = 750;

	private static final long ROW_ALERT_LIMIT = 200;

	private EditorGroupedChartPanel editorPanel;

	private GroupedCharts charts;

	private EditorChartServicePanel editorChartServicePanel = null;

	private ChartSwingManager swingManager;

	private ChartDocument document;

	private boolean isFirstTime = true;

	private boolean allowOnlySelectedRows = false;

	private JDialog dialogParent;

	private HashMap<String, TableDocument> tableDocs;

	public DefaultEditorGroupedChartIWindow(ChartDocument doc) {

		this.document = doc;

		charts = doc.getChartService().copy();

		swingManager = ChartSwingLocator.getSwingManager().getChartSwingManager();

		editorPanel = ChartSwingLocator.getSwingManager().getChartSwingManager().createEditorChartPanel(charts);

		editorPanel.addObserver(this);

		GridBagLayout gridBagLayout = new GridBagLayout();

		/*gridBagLayout.columnWidths = new int[]{0, 0, 655, 0, 0, 0};

		/*gridBagLayout.rowHeights = new int[]{0, 0, 0};

		gridBagLayout.columnWeights = new double[]{0.0, 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE};

		gridBagLayout.rowWeights = new double[]{0.0, 0.0, Double.MIN_VALUE};*/

		setLayout(gridBagLayout);

		JButton acceptButton = new JButton(this.swingManager.getTranslation("accept"));

		acceptButton.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent arg0) {

				updateDocument();

				closeMainWindow();

			}

		});

		acceptButton.setSize(100, acceptButton.getHeight());

		GridBagConstraints gbc_panel = new GridBagConstraints();

		gbc_panel.gridwidth = 5;

		gbc_panel.insets = new Insets(5, 5, 5, 5);

		gbc_panel.gridx = 0;

		gbc_panel.gridy = 0;

		gbc_panel.fill = GridBagConstraints.BOTH;

		gbc_panel.weightx = 1.0;

		gbc_panel.weighty = 1.0;

		add(editorPanel.getComponent(), gbc_panel);

		JButton cancelButton = new JButton(this.swingManager.getTranslation("Cancel"));

		cancelButton.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent arg0) {

				closeMainWindow();

			}

		});

		GridBagConstraints gbc_btnNewButton_2 = new GridBagConstraints();

		gbc_btnNewButton_2.anchor = GridBagConstraints.EAST;

		gbc_btnNewButton_2.insets = new Insets(5, 5, 5, 5);

		gbc_btnNewButton_2.gridx = 4;

		gbc_btnNewButton_2.gridy = 1;

		add(acceptButton, gbc_btnNewButton_2);

		cancelButton.setSize(100, cancelButton.getHeight());

		GridBagConstraints gbc_btnNewButton_1 = new GridBagConstraints();

		gbc_btnNewButton_1.anchor = GridBagConstraints.EAST;

		gbc_btnNewButton_1.insets = new Insets(5, 5, 5, 75);

		gbc_panel.fill = GridBagConstraints.BOTH;

		gbc_panel.weightx = 1.0;

		gbc_panel.weighty = 0.0;

		gbc_btnNewButton_1.gridx = 4;

		gbc_btnNewButton_1.gridy = 1;

		add(cancelButton, gbc_btnNewButton_1);

	}

	protected void closeMainWindow() {

		if(this.dialogParent!=null){

			this.dialogParent.dispose();

		}else{

			PluginServices.getMDIManager().closeWindow(this);

		}

	}

	public void setParentDialog(JDialog parent){

		this.dialogParent = parent;

	}

	public EditorChartServicePanel getEditorChartServicePanel(){

		return this.editorChartServicePanel;

	}

	public TableDocument getDocument(String name){

		if(tableDocs != null && !tableDocs.isEmpty()){

			return tableDocs.get(name);

		}

		return null;

	}

	public WindowInfo getWindowInfo() {

		WindowInfo m_viewinfo = new WindowInfo(WindowInfo.MODALDIALOG

				| WindowInfo.RESIZABLE);

		m_viewinfo

				.setTitle(PluginServices.getText(this, this.swingManager.getTranslation("propiedades_grafico")));

		m_viewinfo.setWidth(830);

		m_viewinfo.setHeight(545);

		return m_viewinfo;

	}

	public Object getWindowProfile() {

		return WindowInfo.PROPERTIES_PROFILE;

	}

	public EditorGroupedChartPanel getEditorPanel() {

		return editorPanel;

	}

	private void initializeDataSource(ChartServiceDataPanel panel) {

		ApplicationManager appManager = ApplicationLocator.getManager();

		final Project project = appManager.getCurrentProject();

		ProjectManager projectManager = appManager.getProjectManager();

		List<Document> tableDocuments = project

				.getDocuments(TableManager.TYPENAME);

		TableDocument[] pts = tableDocuments

				.toArray(new TableDocument[tableDocuments.size()]);

		Properties extendedProps = new Properties();

		tableDocs = new HashMap<String, TableDocument>();

		List<String> tableNames = new ArrayList<String>();

		for (TableDocument t : pts) {

			tableDocs.put(t.getName(), t);

			tableNames.add(t.getName());

		}

		//props.setDataTableModel(tableNames);

		panel.setTableNameModel(tableNames);

		if(tableNames.size() > 0){

			String tableName = panel.getPreviousChartProperties().getChartTableName();

			if(tableName != null && tableName != ""){

				panel.setSelectedTableName(tableName);

				setFieldsForTable(panel, tableName);

			}else{

				panel.setSelectedTableName(tableNames.get(0));

				setFieldsForTable(panel, tableNames.get(0));

			}

		}

		panel.fillTableData();

	}

	private boolean isActivatedPanel(ChartServiceDataPanel panel, long total, long selected){

		if(total>ROW_LIMIT && (selected>ROW_LIMIT || selected ==0)){

			editorChartServicePanel.setDisableChartCreation(false);

			return false;

		}

		return true;

	}

	private void getAlertMessages(ChartServiceDataPanel panel, String tableName){

		ApplicationManager appManager = ApplicationLocator.getManager();

		final Project project = appManager.getCurrentProject();

		TableDocument selDoc = (TableDocument) project.getDocument(tableName,

			TableManager.TYPENAME);

		if (selDoc != null) {

			try {

				long total = selDoc.getStore().getFeatureCount();

				long selected = selDoc.getStore().getFeatureSelection().getSize();

				this.allowOnlySelectedRows=false;

				editorChartServicePanel.setDisableChartCreation(true);

				String text="";

				int messageType = JOptionPane.PLAIN_MESSAGE;			

				if(total>ROW_LIMIT && (selected>ROW_LIMIT || selected == 0)){

					// alert

					text += this.swingManager.getTranslation("chart_data_limit_exceeded");

					text += "\n";

					text += this.swingManager.getTranslation("chart_data_more_info");

					text += "\n";

					messageType = JOptionPane.ERROR_MESSAGE;

					this.allowOnlySelectedRows=true;

					editorChartServicePanel.setDisableChartCreation(false);

				}

				if(total>ROW_LIMIT && selected<ROW_LIMIT && selected>ROW_ALERT_LIMIT){

					if(!panel.getOnlySelectedRows()){

						// alert for that

						text += this.swingManager.getTranslation("chart_data_using_selected_rows");

						text += "\n";

						text += this.swingManager.getTranslation("chart_data_more_info");

						text += "\n";

					}

					this.allowOnlySelectedRows=true;

					// alert for too time

					text += this.swingManager.getTranslation("chart_data_operation_seconds");

					text += "\n";

					messageType = JOptionPane.WARNING_MESSAGE;

				}

				if(total>ROW_LIMIT && selected<=ROW_ALERT_LIMIT && selected > 0){

					if(!panel.getOnlySelectedRows()){

						// alert for that

						text += this.swingManager.getTranslation("chart_data_using_selected_rows");

						text += "\n";

						text += this.swingManager.getTranslation("chart_data_more_info");

						text += "\n";

						messageType = JOptionPane.WARNING_MESSAGE;

					}

					this.allowOnlySelectedRows=true;

				}	

				if(total>ROW_ALERT_LIMIT && total<=ROW_LIMIT && (selected == 0 || selected > ROW_ALERT_LIMIT)){

					// alert for too time

					text += this.swingManager.getTranslation("chart_data_operation_seconds");

					text += "\n";

					messageType = JOptionPane.INFORMATION_MESSAGE;

				}

				if(selected == 0 && panel.getOnlySelectedRows()){

					text += this.swingManager.getTranslation("chart_data_no_rows_selected");

					messageType = JOptionPane.WARNING_MESSAGE;

				}

				panel.setOnlySelectedRows(this.allowOnlySelectedRows);

				if(!text.equals("") && !isFirstTime){

					JOptionPane.showConfirmDialog(this, text,

		                    "Chart data limit exceeded",

		                    JOptionPane.DEFAULT_OPTION,

		                    messageType);

				}

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}

	private void setFieldsForTable(ChartServiceDataPanel panel, String tableName) {

		ApplicationManager appManager = ApplicationLocator.getManager();

		final Project project = appManager.getCurrentProject();

		TableDocument selDoc = (TableDocument) project.getDocument(tableName,

			TableManager.TYPENAME);

		if (selDoc != null) {

			// We get the fields of this table and put them to lstFields

			try {

				long total_rows = selDoc.getStore().getFeatureCount();

				long selected_rows = selDoc.getStore().getFeatureSelection().getSize();

				boolean activated = isActivatedPanel(panel, total_rows, selected_rows);

				FeatureType featType = selDoc.getStore()

						.getDefaultFeatureType();

				FeatureAttributeDescriptor[] atts = featType

						.getAttributeDescriptors();

				List<String> newFields = new ArrayList<String>();

				List<RequiredField> rFields = null;

				if(panel.getPreviousChartProperties().getChartType().equals(panel.getChartProperties().getChartType())){

					rFields = panel.getPreviousChartProperties().getRequiredFields();

				}

				else{

					rFields = panel.getChartProperties().getRequiredFields();

				}

				int j=0;

				for (RequiredField rf : rFields) {

					if (rf.isOptional())

						newFields.add("");

					for (int i = 0; i < atts.length; i++) {

						if(rf.isNumeric()){

							if (atts[i].getDataType().isNumeric()) {

								newFields.add(atts[i].getName());

							}

						}else{

							newFields.add(atts[i].getName());

						 }

					}

					panel.setRequiredFieldModel(rFields, rf, newFields, activated);

					// Seleccionamos el valor previo

					if(rf.getValue()!=null){

						panel.setSelectedRequiredField(rFields, rf, rf.getValue(), activated);

					}

					newFields = new ArrayList<String>();					

					j++;

				}

	//			Properties props = ((ChartPanel) panelProps).getExtendedData();

	//			props.put("fieldsCombo", newFields);

	//			((ChartPanel) panelProps).setExtendedData(props);

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}

	public void update(Observable observable, Object notification) {

		if(observable instanceof EditorGroupedChartPanel){

			EditorGroupedChartPanel editorPanel = (EditorGroupedChartPanel)observable;

			if(notification instanceof GroupedCharts){

				EditorChartPropertiesPanel editorPropertiesPanel = ChartSwingLocator.getSwingManager().getChartSwingManager().createEditorChartPropertiesPanel(

						(ChartService)editorPanel.getGroupedChart(),

						editorPanel.getGroupedChart());

				ChartService service =  EditorChartServiceJDialog.showDialog(

						this.swingManager.getTranslation("General_options"), 

						editorPropertiesPanel

				);

				if(service != null){

					editorPanel.refreshInformation();

				}

			}

			if(notification == null){

				ChartSwingManager swingManager = ChartSwingLocator.getSwingManager().getChartSwingManager();

				editorChartServicePanel = swingManager.createNewChartPanel(this.charts);

				editorChartServicePanel.addObserver(getEditorPanel());

				ChartService service =  EditorChartServiceJDialog.showDialog(

						this.swingManager.getTranslation("Add_new_variable"), 

						editorChartServicePanel);

				if(service != null){

					getEditorPanel().getGroupedChart().addChartService(service);

					getEditorPanel().notifyObservers(getEditorPanel().getGroupedChart(), service);

					int services = getEditorPanel().getGroupedChart().getChartServices().size();

					if(services > 1){

						for(int x=services; x>1; x--){

							ChartService prev_service = getEditorPanel().getGroupedChart().getChartServices().get(x-2);

							service = getEditorPanel().getGroupedChart().getChartServices().get(x-1);

							getEditorPanel().getGroupedChart().updateChartService(x-2, service);

							getEditorPanel().getGroupedChart().updateChartService(x-1, prev_service);

						}

						getEditorPanel().getGroupedChart().refreshCharts();

						getEditorPanel().getGroupedChart().redrawCharts();

						getEditorPanel().getGroupedChart().notifyChange(

								getEditorPanel().getGroupedChart());

					}

				}

				editorChartServicePanel = null;

			}

			if(!(notification instanceof GroupedCharts) &&

					notification instanceof ChartService){

				int index = getEditorPanel().getGroupedChart().getChartServices().indexOf((ChartService)notification);

				createNewChartVariable(index);

			}

			getEditorPanel().getGroupedChart().refreshCharts();

		}

		if(observable instanceof ChartServiceDataPanel){

			if(notification != null && notification instanceof String){

				setFieldsForTable(((ChartServiceDataPanel)observable), (String) notification);

				getAlertMessages(((ChartServiceDataPanel)observable), (String) notification);

				isFirstTime=false;

			}

			if(notification != null && notification instanceof ChartService){

				try {

					if(editorChartServicePanel != null){

						if(editorChartServicePanel.isEditing()){

							getEditorPanel().getGroupedChart().updateChartService(

									editorChartServicePanel.getChartServiceIndexEdited(), 

									editorChartServicePanel.getNewChartService());

							ChartServiceDataPanel dataPanel = (ChartServiceDataPanel)observable;

							dataPanel.fillTableData();

							getEditorPanel().getGroupedChart().updateChartService(

									editorChartServicePanel.getChartServiceIndexEdited(), 

									editorChartServicePanel.getPreviousChartService());

						}else{

							getEditorPanel().getGroupedChart().addChartService(editorChartServicePanel.getNewChartService());

							getEditorPanel().notifyObservers(getEditorPanel().getGroupedChart(), editorChartServicePanel.getNewChartService());

//							ChartServiceDataPanel dataPanel = (ChartServiceDataPanel)observable;

//							editorChartServicePanel.getNewChartService().createChartLegendItems();

//							dataPanel.fillTableData();

							getEditorPanel().getGroupedChart().deleteChartService(editorChartServicePanel.getNewChartService());

						}

					}

					refreshChartServiceData((ChartService)notification);

				} catch (DataException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

			if(notification == null){

				initializeDataSource(((ChartServiceDataPanel)observable));

			}

		}

		if(observable instanceof GroupedCharts){

//			if(notification != null && notification instanceof ChartService){

//				try {

//					refreshChartServiceData((ChartService)notification);

//				} catch (DataException e) {

//					// TODO Auto-generated catch block

//					e.printStackTrace();

//				}

//			}else{

				refreshGroupedChartsData();

//			}

		}

	}

	public void createNewChartVariable(int index) {

		ChartSwingManager swingManager = ChartSwingLocator.getSwingManager().getChartSwingManager();

		editorChartServicePanel = swingManager.createEditorChartPanel(index, this.charts);

		editorChartServicePanel.addObserver(getEditorPanel());

		ChartService service =  EditorChartServiceJDialog.showDialog(

				this.swingManager.getTranslation("Edit_a_variable"),

				editorChartServicePanel);

		if(service != null){

			getEditorPanel().getGroupedChart().updateChartService(index, service);

			getEditorPanel().getGroupedChart().refreshCharts();

			getEditorPanel().getGroupedChart().redrawCharts();

			getEditorPanel().getGroupedChart().notifyChange(

					getEditorPanel().getGroupedChart());

			getEditorPanel().notifyObservers(getEditorPanel().getGroupedChart(), service);

		}

		editorChartServicePanel = null;

	}

	public ChartDocument getChartDocument(){

		return this.document;

	}

	private void updateDocument(){

		getChartDocument().setChartService(this.charts);

	}

	/**

	 * We read the actual data and create the ChartDataSet

	 * @param cs

	 * @throws DataException

	 */

	public void refreshChartServiceData(ChartService cs) throws DataException{

		ApplicationManager appManager = ApplicationLocator.getManager();

		Project project = appManager.getCurrentProject();

		ChartProperties cp = cs.getChartProperties();

		FeatureSet fs;

		String tableName = cs.getChartProperties().getChartTableName();

		if(tableName != null){

			TableDocument table = (TableDocument) project.getDocument(

					tableName, TableManager.TYPENAME);

			if (table == null) {

				throw new RuntimeException("No se encuentra la tabla "

						+ tableName);

			}

			ChartDataSet dataSet = cs.getChartDataSet();

			FeatureSelection fsel = table.getStore().getFeatureSelection();

			fs = table.getStore().getFeatureSet(); 

			DisposableIterator it = null;

			if (cp.getUseSelectedFeatures()) {

				it = fsel.fastIterator();

			}

			else {

				it = fs.fastIterator();

			}

			int[] fieldIDs = new int[cp.getRequiredFields().size()];

			ArrayList[] data = new ArrayList[cp.getRequiredFields().size()];

			// Buscamos los ID de los campos que vamos a usar.

			for (int j = 0; j < cp.getRequiredFields().size(); j++) {

				RequiredField rq = cp.getRequiredFields().get(j);

					if (fs.getDefaultFeatureType()

							.getAttributeDescriptor(rq.getValue()) == null)

						fieldIDs[j] = -1;

					else{

						fieldIDs[j] = fs.getDefaultFeatureType()

							.getAttributeDescriptor(rq.getValue()).getIndex();

					}

				ArrayList<Object> aux = new ArrayList<Object>();

				data[j] = aux;

			}

			// if onlyRecordsSelected is set, we should iterate by selected features only

			while (it.hasNext()) {

				Feature f = (Feature) it.next();

				for (int j = 0; j < fieldIDs.length; j++) {

					if (fieldIDs[j] != -1)

						data[j].add(f.get(fieldIDs[j]));

				}

			}

			for (int j = 0; j < fieldIDs.length; j++) {

				RequiredField rq = cp.getRequiredFields().get(j);

				if (fieldIDs[j] != -1)

					dataSet.addData(rq.getName(),

						data[j]);

			}

			it.dispose();

			cs.setChartDataSet(dataSet);

		}

	}

	public void refreshGroupedChartsData() {

		List<ChartService> chartServices = charts.getChartServices();

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

			try {

				ChartService cs = chartServices.get(i);

				refreshChartServiceData(cs);

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

//		try {

//			overlay = this.chartDocumentContext.getMainChart();

//			

//			if(overlay instanceof GroupedCharts){

//				GroupedCharts oc = (GroupedCharts)overlay;

//				oc.setChartServices(chartServices);

//				

//				this.previewPanel.setChartService(overlay);

//			}

//			

//		} catch (ServiceException e) {

//			// TODO Auto-generated catch block

//			e.printStackTrace();

//		}

	}

	public void setEditorChartServicePanel(

			EditorChartServicePanel createNewChartPanel) {

		this.editorChartServicePanel = createNewChartPanel;

	}

}

package org.gvsig.app.project.documents.chart.gui;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.JPanel;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindowListener;

import org.gvsig.andami.ui.mdiManager.IWindowTransform;

import org.gvsig.andami.ui.mdiManager.SingletonWindow;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.chart.ChartDocument;

import org.gvsig.app.project.documents.chart.events.ChartPropertiesChangeEvent;

import org.gvsig.app.project.documents.chart.events.ChartPropertiesChangeListener;

import org.gvsig.app.project.documents.gui.IDocumentWindow;

import org.gvsig.app.project.documents.gui.WindowLayout;

import org.gvsig.chart.swing.ChartSwingLocator;

import org.gvsig.chart.swing.ViewChartPanel;

public class DefaultChartDocumentPanel extends JPanel 

	implements ChartPropertiesChangeListener,IDocumentWindow, IWindowListener, IWindowTransform, SingletonWindow {

	/**

	 * 

	 */

	private static final long serialVersionUID = -3830098539680196793L;

    private static final int DEFAULT_HEIGHT = 400;

    private static final int DEFAULT_WIDTH = 800;

//	private static MapControlManager mapControlManager = MapControlLocator.getMapControlManager();

	private ChartDocument model = null;

    private WindowInfo m_viewInfo = null;

    private ViewChartPanel mainPanel = null;

	public DefaultChartDocumentPanel(){

		super();

    	this.initialize();

	}

	public DefaultChartDocumentPanel(Document document) {

    	super();

    	this.model = (ChartDocument) document;

    	this.initialize();

    	this.setDocument(document);

    }

	public void initialize() {

    	this.setName("Chart");

//    	//TODO Remove this when the system to load libraries is finished

//    	if (mapControlManager == null){

//    		 mapControlManager = MapControlLocator.getMapControlManager();

//    	}

		ViewChartPanel chartPanel = ChartSwingLocator.getSwingManager().getChartSwingManager().createViewChartPanel(getChartDocument().getChartService());

		this.mainPanel = chartPanel;

		this.setLayout(new BorderLayout());

		this.add(chartPanel.getComponent(), BorderLayout.CENTER);

	}

	public void windowActivated() {

		// TODO Auto-generated method stub

	}

	public void windowClosed() {

		// TODO Auto-generated method stub

	}

	public void toPalette() {

		// TODO Auto-generated method stub

	}

	public void restore() {

		// TODO Auto-generated method stub

	}

	public boolean isPalette() {

		// TODO Auto-generated method stub

		return false;

	}

	public Object getWindowModel() {

		return this.model.getName();

	}

	public WindowInfo getWindowInfo() {

		if (m_viewInfo == null) {

            m_viewInfo =

                new WindowInfo(WindowInfo.ICONIFIABLE | WindowInfo.RESIZABLE

                    | WindowInfo.MAXIMIZABLE);

            m_viewInfo.setWidth(DEFAULT_WIDTH);

            m_viewInfo.setHeight(DEFAULT_HEIGHT);

            m_viewInfo.setTitle(PluginServices.getText(this, "Chart") + " : "

                + this.getWindowModel());

        }

        return m_viewInfo;

	}

	public Object getWindowProfile() {

		return WindowInfo.PROPERTIES_PROFILE;

	}

	public WindowLayout getWindowLayout() {

		return null;

	}

	public void setWindowLayout(WindowLayout layout) {

	}

	public void setDocument(Document document) {

		if(this.model == null){

			this.model = (ChartDocument) document;

		}

		this.setName(document.getName());

//			chartProperties = this.model.getChartProperties();

//			ChartService chartService = ChartLocator.getServiceManager().getChartManager().createChart(chartProperties);

////			chartService.setDataset(data)

////			ChartDataSet chartDataset = this.model.getChartDataset();

////			chartService.setDataset(chartDataset);

//			getChartPanel().setChartService(chartService);

//			this.getChartPanel().setChartService(chartService);

//		} catch (ServiceException e) {

//			// TODO Auto-generated catch block

//			e.printStackTrace();

//		}

		this.model.addPropertyChangeListener(new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                if (evt.getPropertyName().equals("name")) {

                    PluginServices

                        .getMDIManager()

                        .getWindowInfo(DefaultChartDocumentPanel.this)

                        .setTitle(

                            PluginServices.getText(this, "Chart") + " : "

                                + (String) evt.getNewValue());

                }

            }

        });

	}

	public Document getDocument() {

		return this.model;

	}

	public ChartDocument getChartDocument() {

		if(this.model instanceof ChartDocument)

			return (ChartDocument) this.model;

		return null;

	}

	 public ViewChartPanel getChartPanel() {

	    return this.mainPanel;

	 }

	 public void setChartPanel(ViewChartPanel panel) {

        if (this.mainPanel != null) {

            remove(this.mainPanel.getComponent());

        }

        this.mainPanel = panel;

        add(this.mainPanel.getComponent());

        Dimension prefSize = this.mainPanel.getComponent().getPreferredSize();

        this.setSize(prefSize);

        this.repaint();

	 }

	// Cuando el Properties cambia, repinta le panel

	public void chartPropertiesChange(ChartPropertiesChangeEvent evt) {

		System.out.println("ChartDocument: chartPropertiesChange");

		getChartPanel().setOverlayChart(this.getChartDocument().getChartService());

		repaint();

////		this.getChartDocument().getChartService().draw(

////				(Graphics2D) this.getGraphics(), 

////				this.getBounds());

//		

	}

}

package org.gvsig.app.project.documents.chart.gui;

import java.awt.Dimension;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import javax.swing.JDialog;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.swing.editors.EditorChartServicePanel;

/**

 * A dialog for choosing a font from the available system fonts.

 *

 * @author Jos? Bad?a

 */

public class DefaultEditorChartServiceJDialog  extends JDialog {

    /**

	 * 

	 */

	private static final long serialVersionUID = 822457766380562414L;

    private EditorChartServicePanel editorPanel;

    /**

     * Standard constructor - builds a font chooser dialog owned by another dialog.

     *

     * @param owner  the dialog that 'owns' this dialog.

     * @param title  the title for the dialog.

     * @param modal  a boolean that indicates whether or not the dialog is modal.

     * @param font  the initial font displayed.

     */

    public DefaultEditorChartServiceJDialog(String title, boolean modal, EditorChartServicePanel panel) {

        super();

        editorPanel = panel;

        setTitle(title);