gvSIG tools: basic charts

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.

<?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="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

/* 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.app.chart.mainplugin;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JDialog;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.plugins.ExclusiveUIExtension;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.andami.plugins.IExtension;

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

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

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

import org.gvsig.app.project.documents.chart.gui.DefaultChartDocumentPanel;

import org.gvsig.app.project.documents.chart.gui.DefaultEditorGroupedChartIWindow;

import org.gvsig.app.project.documents.chart.gui.EditorChartServiceJDialog;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartService;

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

import org.gvsig.chart.swing.ChartSwingLocator;

import org.gvsig.chart.swing.ChartSwingManager;

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

import org.gvsig.chart.swing.spi.ChartSwingServiceManager;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.util.Caller;

import org.gvsig.tools.util.impl.DefaultCaller;

import org.jfree.ui.ExtensionFileFilter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Andami extension to show Chart in the application.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class ChartExtension extends Extension implements ExclusiveUIExtension {

	static ImageIcon LOGO;

	private static final Logger logger = LoggerFactory

			.getLogger(ChartExtension.class);

	private static final String MY_VIEW_NAME = "Chart plugin";

	private static final String TOOL_NAME = "Chart.infotool";

	private static final String ACTION_CREATEPLOT = "chart-create-plot";

	private static final String ACTION_EDITPLOT = "chart-edit-plot";

	private static final String ACTION_EXPORTTOPDF = "chart-export-pdf";

	private static final String ACTION_EXPORTTOPNG = "chart-export-png";

	private ChartServiceManager manager;

	private ChartSwingServiceManager swingServiceManager;

	private ChartSwingManager swingManager;

	public void initialize() {

		registerIcons();

	}

	public void postInitialize() {

		manager = ChartLocator.getServiceManager();

		swingServiceManager = ChartSwingLocator.getSwingManager();

		swingManager = swingServiceManager.getChartSwingManager();

		// initializeDocumentActionsExtensionPoint();

		try {

			registerIcons();	

		}

		catch (Exception e) {

			e.printStackTrace();

		}

		ChartDocumentManager.register();

		// registerContextMenuOptions();

		Caller caller = new DefaultCaller();

		/*

         * Add registry of persistent styles

         */

        caller.add( new ChartDocument.RegisterPersistence() );

        /*

         * Do register of all

         */

        if( !caller.call() ) {

        	throw new LibraryException(ChartExtension.class, caller.getExceptions());

        }

	}

	/**

	 * Execute the actions associated to this extension.

	 */

	public void execute(String actionCommand) {

		if (ACTION_EDITPLOT.equalsIgnoreCase(actionCommand)) {

			IWindow window = PluginServices.getMDIManager().getActiveWindow();

			if ((window instanceof DefaultChartDocumentPanel)) {

//				DefaultChartDocumentPanel chartPanel = (DefaultChartDocumentPanel) window;

//				EditorGroupedChartPanel editor = ChartSwingLocator.getSwingManager().getChartSwingManager().createEditorChartPanel(

//						(GroupedCharts)chartPanel.getChartPanel().getOverlayChart());

				DefaultChartDocumentPanel chartPanel = (DefaultChartDocumentPanel) window;

				ChartDocument document = (ChartDocument)chartPanel.getDocument();

				DefaultEditorGroupedChartIWindow windowPanel = 

					new DefaultEditorGroupedChartIWindow(document);

				JDialog dlg = new JDialog();

//				dlg.getContentPane().add(editor.getComponent());

				windowPanel.setParentDialog(dlg);

				dlg.getContentPane().add(windowPanel);

//				dlg.pack();

				dlg.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);

				dlg.setPreferredSize(new Dimension(700, 600));

				dlg.setModal(true);

				dlg.pack();

				dlg.setSize(840, 650);

				dlg.setVisible(true);

				return;

			}

		}

		if (ACTION_CREATEPLOT.equalsIgnoreCase(actionCommand)) {

			IWindow window = PluginServices.getMDIManager().getActiveWindow();

			if ((window instanceof DefaultChartDocumentPanel)) {

				DefaultChartDocumentPanel chartPanel = (DefaultChartDocumentPanel) window;

				ChartDocument document = (ChartDocument)chartPanel.getDocument();

				DefaultEditorGroupedChartIWindow windowPanel = 

					new DefaultEditorGroupedChartIWindow(document);

				EditorChartServicePanel editorChartServicePanel = swingManager.createNewChartPanel(windowPanel.getChartDocument().getChartService());

				editorChartServicePanel.addObserver(windowPanel.getEditorPanel());

				windowPanel.setEditorChartServicePanel(

						editorChartServicePanel

				);

				ChartService service = EditorChartServiceJDialog.showDialog(

						this.swingManager.getTranslation("Add_new_variable"),

						windowPanel.getEditorChartServicePanel());

				if(service != null){

					document.getChartService().addChartService(service);

				}

				windowPanel.setEditorChartServicePanel(null);

//				JDialog dlg = new JDialog();

//				dlg.setTitle("Add variable to current Chart");

////				dlg.setContentPane(new ChartUsedFieldPanel(document));

//				dlg.pack();

//				dlg.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);

//

//				dlg.setVisible(true);

				return;

			}

		}

		if (ACTION_EXPORTTOPDF.equalsIgnoreCase(actionCommand)) {

			IWindow window = PluginServices.getMDIManager().getActiveWindow();

			if ((window instanceof DefaultChartDocumentPanel)) {

				DefaultChartDocumentPanel chartPanel = (DefaultChartDocumentPanel) window;

				ChartDocument document = (ChartDocument)chartPanel.getDocument();

				JFileChooser chooser = new JFileChooser();

				ExtensionFileFilter filter=new ExtensionFileFilter(this.swingManager.getTranslation("PDF_Image_Files"),".pdf");

				chooser.addChoosableFileFilter(filter);

				chooser.setCurrentDirectory(new File(System.getProperty("user.home")));

				chooser.setDialogTitle(this.swingManager.getTranslation("SavePDF"));

				chooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES );

//				chooser.setAcceptAllFileFilterUsed(true);

				if (chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) {

//				  System.out.println("getCurrentDirectory(): " + chooser.getCurrentDirectory());

//				  System.out.println("getSelectedFile() : " + chooser.getSelectedFile().getAbsolutePath());

//				  

				  String filename = chooser.getSelectedFile().getAbsolutePath();

				  if (!filename.endsWith(".pdf")) {

			        filename=filename + ".pdf";

			      }

				  document.getChartService().exportAsPDF(

						    filename, 

							chartPanel.getWidth(), 

							chartPanel.getHeight()

					);

				  	JOptionPane.showMessageDialog(null, this.swingManager.getTranslation("Document_exported"));

				} else {

				  System.out.println("No Selection ");

				}

				return;

			}

		}

		if (ACTION_EXPORTTOPNG.equalsIgnoreCase(actionCommand)) {

			IWindow window = PluginServices.getMDIManager().getActiveWindow();

			if ((window instanceof DefaultChartDocumentPanel)) {

				DefaultChartDocumentPanel chartPanel = (DefaultChartDocumentPanel) window;

				JFileChooser chooser = new JFileChooser();

				ExtensionFileFilter filter=new ExtensionFileFilter(this.swingManager.getTranslation("PNG_Image_Files"),".png");

				chooser.addChoosableFileFilter(filter);

				chooser.setCurrentDirectory(new File(System.getProperty("user.home")));

				chooser.setDialogTitle(this.swingManager.getTranslation("SavePNG"));

				chooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES );

//				chooser.setAcceptAllFileFilterUsed(true);

				if (chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) {

//				  System.out.println("getCurrentDirectory(): " + chooser.getCurrentDirectory());

//				  System.out.println("getSelectedFile() : " + chooser.getSelectedFile().getAbsolutePath());

//				  

				  String filename = chooser.getSelectedFile().getAbsolutePath();

				  if (!filename.endsWith(".png")) {

			        filename=filename + ".png";

			      }

				 BufferedImage bi = this.createImage(chartPanel, chartPanel.getBounds());

				 this.writeImage(bi, filename);

				 JOptionPane.showMessageDialog(null, this.swingManager.getTranslation("Document_exported"));

				} else {

				  System.out.println("No Selection ");

				}

				return;

			}

		}

	}

	public void writeImage(BufferedImage image, String fileName){

		if (fileName == null) return;

		int offset = fileName.lastIndexOf( "." );

		if (offset == -1){

			return;

		}

		String type = fileName.substring(offset + 1);

		try {

			ImageIO.write(image, type, new File( fileName ));

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	private BufferedImage createImage(JComponent component, Rectangle region)

	{

        //  Make sure the component has a size and has been layed out.

        //  (necessary check for components not added to a realized frame)

		if (! component.isDisplayable())

		{

			Dimension d = component.getSize();

			if (d.width == 0 || d.height == 0)

			{

				d = component.getPreferredSize();

				component.setSize( d );

			}

//			layoutComponent( component );

		}

		BufferedImage image = new BufferedImage(region.width, region.height, BufferedImage.TYPE_INT_RGB);

		Graphics2D g2d = image.createGraphics();

		//  Paint a background for non-opaque components,

		//  otherwise the background will be black

		if (! component.isOpaque())

		{

			g2d.setColor( component.getBackground() );

			g2d.fillRect(region.x, region.y, region.width, region.height);

		}

		g2d.translate(-region.x, -region.y);

		component.paint( g2d );

		g2d.dispose();

		return image;

	}

	/**

	 * Check if tools of this extension are enabled.

	 */

	public boolean isEnabled() {

		//

		// By default the tool is always enabled

		//

		return true;

	}

	/**

	 * Check if tools of this extension are visible.

	 */

	public boolean isVisible() {

		IWindow f = PluginServices.getMDIManager().getActiveWindow();

		if (f == null) {

			return false;

		}

		if (f instanceof DefaultChartDocumentPanel) {

			return true;

		}

		return false;

	}

	/**

	 * Check if an extension is enabled.

	 */

	public boolean isEnabled(IExtension extension) {

		return extension.isEnabled();

	}

	/**

	 * Check if an extension is visible.

	 */

	public boolean isVisible(IExtension extension) {

		return extension.isVisible();

	}

	private void registerIcons() {

		IconThemeHelper.registerIcon("chart", "chart-create-plot", this.getClass());

		IconThemeHelper.registerIcon("chart", "chart-edit-plot", this.getClass());

		IconThemeHelper.registerIcon("chart", "chart-export-pdf", this.getClass());

		IconThemeHelper.registerIcon("chart", "chart-export-png", this.getClass());

		IconThemeHelper.registerIcon("document", "document-chart-unselect", ChartDocumentManager.class);

		IconThemeHelper.registerIcon("document", "document-chart-select", ChartDocumentManager.class);

	}

}

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>org.gvsig.landregistryviewer package documentation</title>

</head>

<body>

	<p>LandRegistryViewer gvSIG extension</p>

	<p>

	Shows LandRegistryViewer into gvSIG.

	</p>

</body>

</html>

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

import java.util.HashMap;

import javax.swing.ImageIcon;

import javax.swing.JPanel;

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

import org.gvsig.andami.PluginServices;

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

import org.gvsig.app.project.ProjectManager;

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

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

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

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

import org.gvsig.app.project.documents.chart.gui.DefaultChartDocumentPanel;

import org.gvsig.app.project.documents.chart.gui.DefaultEditorGroupedChartIWindow;

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

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

import org.gvsig.fmap.IconThemeHelper;

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.swing.FilesystemExplorerWizardPanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ChartDocumentManager extends AbstractDocumentManager implements DocumentManager{

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

	public static final String PERSISTENCE_CHART_DOCUMENT_DEFINITION_NAME = "ChartDocumentManager";

    public static String TYPENAME = "project.document.chart";

    private DynStruct persistenceDefinition = null;

    private HashMap<Document, JPanel> documents = new HashMap<Document, JPanel>();

    private DefaultEditorGroupedChartIWindow propertiesPanel;

	private static final String CHART_WIZARD_EXTENSION_POINT = "ChartWizardExtensionPoint";

	private static final String CHART_WIZARD_NAME = "ChartWizard";

	private static ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

	public DynStruct getDefinition(String className) {

		if( this.persistenceDefinition.getName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if( this.persistenceDefinition.getFullName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if( this.getDocumentClass().getName().equals(className) ) {

            return this.persistenceDefinition;

        }

		return null;

	}

	public AbstractDocument createDocument() {

		return new ChartDocument(this);

	}

	public String getTypeName() {

		return TYPENAME;

	}

    public ImageIcon getIcon() {

        return PluginServices.getIconTheme().get("document-chart-unselect");

    }

    public ImageIcon getIconSelected() {

        return PluginServices.getIconTheme().get("document-chart-select");

    }

    public String getTitle() {

        return PluginServices.getText(this, "Charts");

    }

	public IWindow getMainWindow(Document doc, WindowLayout layout) {

		IDocumentWindow chartPanel;

//		chartPanel =

//            (IDocumentWindow) PluginServices.getMDIManager()

//                .getSingletonWindow(getMainWindowClass(), doc);

		chartPanel = (IDocumentWindow) this.getDocumentWindow(doc);

        if (chartPanel != null) {

            // The table window document is already created, return it.

            return chartPanel;

        }

        chartPanel = (IDocumentWindow) this.createDocumentWindow(doc);

        if(chartPanel instanceof DefaultChartDocumentPanel){

        	((ChartDocument)doc).addChartPropertiesChangeEventListener((DefaultChartDocumentPanel)chartPanel);

        }

        this.registerDocumentWindow(doc, (JPanel) chartPanel);

        if (layout != null && chartPanel != null) {

        	chartPanel.setWindowLayout(layout);

        }

        ((AbstractDocument) doc).raiseEventCreateWindow(chartPanel);

        return chartPanel;

	}

	private void registerDocumentWindow(Document doc, JPanel chartPanel) {

		documents.put(doc, chartPanel);

	}

	private IWindow getDocumentWindow(Document doc){

		if(documents.containsKey(doc)){

			return (IWindow) documents.get(doc);

		}

		return null;

	}

	public IWindow getPropertiesWindow(Document doc) {

//		if(propertiesPanel == null) {			

		propertiesPanel = new DefaultEditorGroupedChartIWindow(((ChartDocument)doc));

//		}

		return (IWindow) propertiesPanel;

	}

	@Override

	protected Class getDocumentClass() {

		return ChartDocument.class;

	}

	public static void register() {

		ChartDocumentManager factory = new ChartDocumentManager();

  		// A?adimos nuestra extension para el tratamiento de la apertura de ficheros

  		// dentro de gvSIG

  		ToolsLocator.getExtensionPointManager().

  			add("FileChartOpenDialog", "")

  				.append("FileOpenChart", "",	FilesystemExplorerWizardPanel.class);

  		ProjectManager.getInstance().registerDocumentFactory(factory);

//        ProjectFactory.getInstance().registerDocumentAction(TYPENAME,"copy",new CopyDocumentContextMenuAction());

//        ProjectFactory.getInstance().registerDocumentAction(TYPENAME,"cut",new CutDocumentContextMenuAction());

//        ProjectFactory.getInstance().registerDocumentAction(TYPENAME,"paste",new PasteDocumentContextMenuAction());

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        manager.registerFactory(factory);

        if (factory.persistenceDefinition == null){

            DynObjectManager dynman = ToolsLocator.getDynObjectManager();

            factory.persistenceDefinition = dynman.createDynClass(PersistenceManager.PERSISTENCE_NAMESPACE,

                PERSISTENCE_CHART_DOCUMENT_DEFINITION_NAME,

                "Chart document Persistence definition");

            factory.persistenceDefinition.extend(manager.getDefinition(AbstractDocument.PERSISTENCE_DEFINITION_NAME));

            factory.persistenceDefinition.addDynFieldObject("store").setClassOfValue(FeatureStore.class).setMandatory(true);

            factory.persistenceDefinition.addDynFieldString("featureTypeId").setMandatory(false);

            factory.persistenceDefinition.addDynFieldArray("attributeNames").setClassOfItems(String.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("query").setClassOfValue(FeatureQuery.class).setMandatory(false);

        }

	}

//    public Iterator<? extends Document> createDocumentsByUser() {

//        AddLayerDialog fopen = null;

//        try {

//            fopen =

//                new AddLayerDialog(PluginServices.getText(this, "Nueva_grafica"));

//            List<WizardPanel> wizards =

//                ApplicationLocator.getManager().getWizardPanels();

//            WizardPanel panel;

//            Iterator<WizardPanel> iter = wizards.iterator();

//            while (iter.hasNext()) {

//                panel = iter.next();

//                fopen.addWizardTab(panel.getTabName(), panel);

//                panel.initWizard();

//            }

//            PluginServices.getMDIManager().addWindow(fopen);

//            if (fopen.isAccepted()) {

//                panel = (WizardPanel) fopen.getSelectedTab();

//                @SuppressWarnings("unchecked")

//                List<ChartDocument> docs =

//                    (List<ChartDocument>) panel.executeWizard();

//                return docs.iterator();

//            }

//        } catch (Exception e) {

//            NotificationManager.addError(e);

//        } finally {

//            if (fopen != null) {

//                fopen.dispose();

//                fopen = null;

//            }

//        }

//        return null;

//    }

//

//    public AbstractDocument createDocumentByUser() {

//        return (AbstractDocument) createDocumentsByUser().next();

//    }

	public AbstractDocument createDocumentByUser(){

		AbstractDocument doc = createDocument();

		IWindow  propsWindow = getPropertiesWindow(doc);

		return doc;

	}

	public boolean manages(Object object) {

		return object instanceof ChartDocument;

	}

	public Class getMainWindowClass() {

		return DefaultChartDocumentPanel.class;

	}

}

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.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.events;

import java.util.EventListener;

public interface ChartPropertiesChangeListener extends EventListener {

    public void chartPropertiesChange(ChartPropertiesChangeEvent evt);

}

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>();