gvSIG tools: basic charts

package org.gvsig.chart.base.pie;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartManager;

import org.gvsig.chart.base.pie.renderers.PieChartRendererBasic;

import org.gvsig.chart.impl.AbstractChartProperties;

import org.gvsig.chart.impl.model.variables.DefaultRequiredField;

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

import org.gvsig.chart.renderer.ChartRenderer;

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 PieChartProperties extends AbstractChartProperties{

        public PieChartProperties(){

                super("PieChart");

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

                setChartType("PieChart");

                setChartName(manager.getTranslation("PieChart"));

                ChartRenderer renderer = new PieChartRendererBasic();

                setChartRenderer(renderer.getChartRendererName());

                RequiredField field1 = new DefaultRequiredField();

                field1.setName("series");

                field1.setDescription(manager.getTranslation("labels"));

                field1.setType((ToolsLocator.getDataTypesManager().getDataType(String.class)).getName());

                RequiredField field2 = new DefaultRequiredField();

                field2.setName("categories");

                field2.setDescription(manager.getTranslation("values"));

                field2.setType((ToolsLocator.getDataTypesManager().getDataType(Double.class)).getName());

                RequiredField field3 = new DefaultRequiredField();

                field3.setName("groupby");

                field3.setDescription(manager.getTranslation("groupedBy"));

                field3.setType((ToolsLocator.getDataTypesManager().getDataType(String.class)).getName());

                field3.setIsOptional(true);

                addRequiredField(field1);

                addRequiredField(field2);

                addRequiredField(field3);

        }

        public static void registerDefinition(){

                DynObjectManager manager = ToolsLocator.getDynObjectManager();

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

                if(definition == null){

                        definition = manager.createDynClass("Chart", "PieChartProperties", "aqu? va la descripci?n");

                        definition.addDynFieldFloat("radius").setMandatory(false).setDefaultFieldValue(0.0f);

                        definition.addDynFieldBoolean("isBasic").setMandatory(false).setDefaultFieldValue(true);

                        definition.addDynFieldBoolean("hasExplotedSections").setMandatory(false).setDefaultFieldValue(false);

                        definition.addDynFieldBoolean("is3D").setMandatory(false).setDefaultFieldValue(false);

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

                        manager.add(definition);

                }

        }

//        public static void registerPersistentDefinition(){

//                PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

//                if(definition == null){

//                        definition = manager.addDefinition(PieChartProperties.class, "PieChartProperties", "aqu? va la descripci?n", null, null);

//                        definition.addDynFieldFloat("radius").setMandatory(false);

//                        

//                        

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

//                        definition.addDynFieldBoolean("hasExplotedSections").setMandatory(true).setDefaultFieldValue(false);

//                        definition.addDynFieldBoolean("is3D").setMandatory(true).setDefaultFieldValue(false);

//                        

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

//                }

//        }

        public void setPieChartRadius(Float radius) {

                data.setDynValue("radius", radius);

        }

        public Float getPieChartRadius() {

                return (Float) data.getDynValue("radius");

        }

        public void setIs3D(boolean is3d) {

                data.setDynValue("is3d", is3d);

        }

        public boolean getIs3D() {

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

        }

        public void setIsBasicChart(boolean isBasic) {

                data.setDynValue("isBasic", isBasic);

        }

        public boolean getIsBasicChart() {

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

        }

        public void setHasExploitedSections(boolean hasExplotedSections) {

                data.setDynValue("hasExplotedSections", hasExplotedSections);

        }

        public boolean getHasExploitedSections() {

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

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                // Save parent properties

                super.saveToState(state);

                // Save own properties

                state.set("is3D", this.getIs3D());

                state.set("isBasic", this.getIsBasicChart());

                state.set("radius", this.getPieChartRadius());

                state.set("hasExplotedSections", this.getHasExploitedSections());

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                // Set parent properties

                super.loadFromState(state);

                // Set own properties

                this.setIs3D(state.getBoolean("is3D"));

                this.setIsBasicChart(state.getBoolean("isBasic"));

                this.setPieChartRadius(state.getFloat("radius"));

                this.setHasExploitedSections(state.getBoolean("hasExplotedSections"));

        }

        public static class RegisterPersistence implements Callable {

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                                DynStruct definition = manager.addDefinition(

                                                PieChartProperties.class,

                                                "PieChartProperties",

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

                                                null, 

                                                null

                                );

//                                // Extend the Classified Vector Legend base definition

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

                                // Values

                                definition.addDynFieldFloat("radius");

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

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

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

                        }

                        return Boolean.TRUE;

                }

        }

}