Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.complexlabel.impl;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.LabelClass;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.util.Callable;

public class DefaultComplexLabelClass extends LabelClass implements Persistent{

        public static final String COMPLEXLABELCLASS_PERSISTENCE_DEFINITION_NAME = "Complex.label.class";

        private double minScale;

        private double maxScale;

        public double getMinScale() {

                return minScale;

        }

        public void setMinScale(double minScale) {

                this.minScale = minScale;

        }

        public double getMaxScale() {

                return maxScale;

        }

        public void setMaxScale(double maxScale) {

                this.maxScale = maxScale;

        }

        @Override

        public boolean isVisible() {

                return super.isVisible();

        }

        @Override

        public boolean isVisible(double scale) {

                if(getMaxScale() > scale && getMinScale() < scale){

                        return true;

                }

                return false;

        }

        @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                super.loadFromState(state);

                setMinScale(state.getDouble("MinScale"));

                setMaxScale(state.getDouble("MaxScale"));

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set("MinScale", getMinScale());

                state.set("MaxScale", getMaxScale());

        }

        @Override

        public Object clone() throws CloneNotSupportedException {

                DefaultComplexLabelClass cloned = (DefaultComplexLabelClass) super.clone();

                cloned.setMaxScale(this.getMaxScale());

                cloned.setMinScale(this.getMinScale());

                return cloned;

        }

        public static class RegisterPersistence implements Callable {

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

                        if( manager.getDefinition(COMPLEXLABELCLASS_PERSISTENCE_DEFINITION_NAME)==null ) {

                                DynStruct definition = manager.addDefinition(

                                                DefaultComplexLabelClass.class,

                                                COMPLEXLABELCLASS_PERSISTENCE_DEFINITION_NAME,

                                                COMPLEXLABELCLASS_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

                                                null, 

                                                null

                                );

                                definition.extend(manager.getDefinition(

                                                "LabelClass"));

                                definition.addDynFieldDouble("MaxScale").setMandatory(true);

                                definition.addDynFieldDouble("MinScale").setMandatory(true);

                        }

                        return Boolean.TRUE;

                }

        }

}