Application: gvSIG desktop » gvSIG legends: base legends

Put into this folder the resources needed by your classes.

This folder is added to the 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 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.construc">

		<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.complexlegend.main;

import java.awt.BorderLayout;

import java.awt.Dimension;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

import javax.swing.WindowConstants;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontrol.MapControlCreationException;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.tools.locator.LocatorException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.jgoodies.looks.plastic.PlasticLookAndFeel;

import com.jgoodies.looks.plastic.PlasticXPLookAndFeel;

/**

 * Main executable class for testing the Chart library.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class Main {

	private static final Logger LOG = LoggerFactory.getLogger(Main.class);

	public static void main(String args[]) throws MapControlCreationException,

			LocatorException, LoadLayerException, UnsupportedLookAndFeelException {

		new DefaultLibrariesInitializer().fullInitialize();

		PlasticLookAndFeel laf = new PlasticXPLookAndFeel();

		UIManager.setLookAndFeel(laf);

		Main main = new Main();

		main.show();

	}

	@SuppressWarnings("serial")

    public void show() throws MapControlCreationException, LocatorException, LoadLayerException {

        JFrame frame = new JFrame("Example APP");

        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        JPanel content = new JPanel();

        content.setLayout(new BorderLayout());

        frame.add(content);

        frame.setPreferredSize(new Dimension(510, 560));

        // Display the window.

        frame.pack();

        frame.setVisible(true);

    }

}

<?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.construc package documentation</title>

</head>

<body>

	<p>Construc library testing and demo application.</p>

</body>

</html>

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

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

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.complexlegend.main</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.complexlegend.main</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.complexlegend</artifactId>

		<version>1.0.14-SNAPSHOT</version>

	</parent>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.complexlegend.swing.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.complexlegend.swing.impl</artifactId>

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.dynform.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.dynform.impl</artifactId>

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.swing.api</artifactId>

			<type>jar</type>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>

			<scope>runtime</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.operation.jts</artifactId>

			<scope>runtime</scope>

        </dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

        </dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.shp</artifactId>

			<scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.dbf</artifactId>

			<scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

			<scope>runtime</scope>

        </dependency>

        <dependency>

             <groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

         </dependency>

         <dependency>

             <groupId>org.gvsig</groupId>

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

			<scope>runtime</scope>

         </dependency>

         <dependency>

             <groupId>org.gvsig</groupId>

             <artifactId>org.gvsig.tools.evaluator.sqljep</artifactId>

			<scope>runtime</scope>

         </dependency>

         <dependency>

             <groupId>org.gvsig</groupId>

             <artifactId>org.gvsig.proj.lib.proj4j</artifactId>

			<scope>runtime</scope>

		</dependency>

	</dependencies>

</project>

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

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

	<modelVersion>4.0.0</modelVersion>

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

	<packaging>jar</packaging>

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

	<parent>

		<groupId>org.gvsig</groupId>

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

		<version>1.0.232</version>

	</parent>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<scope>compile</scope>

		</dependency>

		 <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

			<groupId>org.gvsig</groupId>

			<artifactId> org.gvsig.app.mainplugin</artifactId>

			<scope>compile</scope>

		</dependency>

	</dependencies>

</project>

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="DEBUG" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

package org.gvsig.complexlegend.impl;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.cresques.cts.ICoordTrans;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.complexlegend.ComplexLegendItem;

import org.gvsig.complexlegend.VectorComplexLegend;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.operations.IHasImageLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.LegendException;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendClearEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendContentsChangedListener;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.SimpleMarkerSymbol;

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.task.Cancellable;

import org.gvsig.tools.util.Callable;

public class DefaultVectorComplexLegend extends AbstractVectorialLegend implements VectorComplexLegend, Persistent {

    public static final String COMPLEX_LEGEND_PERSISTENCE_DEFINITION_NAME = "ComplexLegendPersistence";

    public static final String COMPLEX_LEGEND_NAME = "ComplexLegend";

    public static final String COMPLEX_LEGEND_FIELD = "Legends";

    private List<ComplexLegendItem> legends;

    private boolean useDefault;

    private int shapeType;

    private ISymbol defaultSymbol;

    private int currentLegend;

    private LegendContentsChangedListener changeListener;

    private boolean allowOverlap;

    public DefaultVectorComplexLegend() {

        super();

        SymbolManager manager = MapContextLocator.getSymbolManager();

        this.defaultSymbol = manager.createSymbol(Geometry.TYPES.SURFACE);

        this.allowOverlap = true;

        this.currentLegend = -1;

        this.changeListener = new LegendContentsChangedListener() {

            @Override

            public boolean symbolChanged(SymbolLegendEvent e) {

                fireDefaultSymbolChangedEvent(e);

                return true;

            }

            @Override

            public void legendCleared(LegendClearEvent event) {

                fireDefaultSymbolChangedEvent(new ComplexLegendChangedEvent());

            }

        };

    }

    public List<ComplexLegendItem> getLegends() {

        if (legends == null) {

            legends = new ArrayList<ComplexLegendItem>();

        }

        return Collections.unmodifiableList(legends);

    }

    public List<ComplexLegendItem> getEditedLegends() {

        if (legends == null) {

            legends = new ArrayList<ComplexLegendItem>();

        }

        return legends;

    }

    public boolean isOverlapped(ComplexLegendItem legend) {

        Iterator it = getLegends().iterator();

        while (it.hasNext()) {

            ComplexLegendItem aux = (ComplexLegendItem) it.next();

            if ((aux.getMinScale() == -1

                    && aux.getMaxScale() > legend.getMinScale())) {

                return true;

            }

            if ((aux.getMaxScale() == -1

                    && aux.getMinScale() < legend.getMaxScale())) {

                return true;

            }

            if (!(aux.getMinScale() >= legend.getMaxScale()

                    || aux.getMaxScale() <= legend.getMinScale())) {

                return true;

            }

        }

        return false;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultVectorComplexLegend cloned = (DefaultVectorComplexLegend) super.clone(); //To change body of generated methods, choose Tools | Templates.

        cloned.defaultSymbol = (ISymbol) this.defaultSymbol.clone();

        cloned.legends = new ArrayList<>();

        if (legends != null) {

            for (ComplexLegendItem legend : legends) {

                cloned.add((ComplexLegendItem) legend.clone());

            }

        }

        return cloned;

    }

    public boolean add(ComplexLegendItem legend) {

        if (legends == null) {

            getLegends();

        }

        boolean result = legends.add(legend);

        Collections.sort(legends, new Comparator<ComplexLegendItem>() {

            public int compare(ComplexLegendItem o1, ComplexLegendItem o2) {

                if (o1.getMinScale() == o2.getMinScale()) {

                    return 0;

                }

                return o1.getMinScale() < o2.getMinScale() ? -1 : 1;

            }

        });

        legend.getLegend().addLegendListener(this.changeListener);

        fireDefaultSymbolChangedEvent(new ComplexLegendChangedEvent());

        return result;

    }

    public boolean remove(ComplexLegendItem legend) {

        if (legends == null) {

            getLegends();

        }

        boolean result = legends.remove(legend);

        legend.getLegend().removeLegendListener(changeListener);

        fireDefaultSymbolChangedEvent(new ComplexLegendChangedEvent());

        return result;

    }

    public ComplexLegendItem getLegend(double scale) {

        Iterator<ComplexLegendItem> it = getLegends().iterator();

        while (it.hasNext()) {

            ComplexLegendItem cleg = (ComplexLegendItem) it.next();

            if (cleg.getMinScale() == -1

                    && cleg.getMaxScale() >= scale) {

                return cleg;

            }

            if (cleg.getMinScale() <= scale

                    && cleg.getMaxScale() >= scale) {

                return cleg;

            }

            if (cleg.getMinScale() <= scale

                    && cleg.getMaxScale() == -1) {

                return cleg;

            }

        }

        return null;

    }

    public List<ComplexLegendItem> getLegendsInScale(double scale) {

        Iterator<ComplexLegendItem> it = getLegends().iterator();

        ArrayList<ComplexLegendItem> legendsInScale = new ArrayList<ComplexLegendItem>();

        while (it.hasNext()) {

            ComplexLegendItem cleg = (ComplexLegendItem) it.next();

            if (cleg.getMinScale() == -1

                    && cleg.getMaxScale() >= scale) {

                legendsInScale.add(cleg);

            }

            if (cleg.getMinScale() <= scale

                    && cleg.getMaxScale() >= scale) {

                legendsInScale.add(cleg);

            }

            if (cleg.getMinScale() <= scale

                    && cleg.getMaxScale() == -1) {

                legendsInScale.add(cleg);

            }

        }

        return legendsInScale;

    }

    @Override

    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

            double scale, Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, FeatureQuery fquery,

            PrintAttributes properties) throws LegendException {

        List<ComplexLegendItem> legendsToDraw;

        if (this.getAllowOverlap()) {

            legendsToDraw = this.getLegendsInScale(scale);

        } else {

            legendsToDraw = new ArrayList<>();

            ComplexLegendItem legendInScale = getLegend(scale);

            legendsToDraw.add(legendInScale);

        }

        int n = 0;

        for (ComplexLegendItem legend : legendsToDraw) {

            if (legend != null) {

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

                    setCurrentLegend(n);

                    if (legend.getLegend() instanceof AbstractVectorialLegend) {

                        ((AbstractVectorialLegend) legend.getLegend()).print(g, viewPort, cancel, scale, queryParameters, coordTrans,

                                featureStore, fquery, properties);

                    }

                }

            }

        }

    }

    @Override

    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

            double scale, Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, PrintAttributes properties)

            throws LegendException {

        print(g, viewPort, cancel, scale, queryParameters, coordTrans,

                featureStore, null, properties);

    }

    @Override

    public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

            Cancellable cancel, double scale, Map queryParameters,

            ICoordTrans coordTrans, FeatureStore featureStore)

            throws LegendException {

        List<ComplexLegendItem> legendsToDraw;

        if (this.getAllowOverlap()) {

            legendsToDraw = this.getLegendsInScale(scale);

        } else {

            legendsToDraw = new ArrayList<>();

            ComplexLegendItem legendInScale = getLegend(scale);

            legendsToDraw.add(legendInScale);

        }

        int n = 0;

        for (ComplexLegendItem legend : legendsToDraw) {

            if (legend != null) {

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

                    setCurrentLegend(n);

                    if (legend.getLegend() instanceof AbstractVectorialLegend) {

                        ((AbstractVectorialLegend) legend.getLegend()).draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

                                featureStore);

                    }

                }

            }

        }

    }

    @Override

    protected void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

            Cancellable cancel, double scale, Map queryParameters,

            ICoordTrans coordTrans, FeatureStore featureStore,

            FeatureQuery featureQuery, double dpi) throws LegendException {

        List<ComplexLegendItem> legendsToDraw;

        if (this.getAllowOverlap()) {

            legendsToDraw = this.getLegendsInScale(scale);

        } else {

            legendsToDraw = new ArrayList<>();

            ComplexLegendItem legendInScale = getLegend(scale);

            legendsToDraw.add(legendInScale);

        }

        int n = 0;

        for (ComplexLegendItem legend : legendsToDraw) {

            if (legend != null) {

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

                    setCurrentLegend(n);

                    if (legend.getLegend() instanceof AbstractVectorialLegend) {

                        ((AbstractVectorialLegend) legend.getLegend()).draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

                                featureStore, featureQuery);

                    }

                }

            }

            n++;

        }

    }

    private IVectorLegend getCurrentLegend() {

        if (this.currentLegend >= 0 && getLegends() != null && !getLegends().isEmpty()) {

            return (IVectorLegend) getLegends().get(this.currentLegend).getLegend();

        }

        return null;

    }

    private void setCurrentLegend(int legend) {

        this.currentLegend = legend;

    }

    @Override

    public boolean getAllowOverlap() {

        return this.allowOverlap;

    }

    @Override

    public void setAllowOverlap(boolean allowOverlap) {

        this.allowOverlap = allowOverlap;

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                    COMPLEX_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager

                        .addDefinition(DefaultVectorComplexLegend.class,

                                COMPLEX_LEGEND_PERSISTENCE_DEFINITION_NAME,

                                COMPLEX_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

                definition.extend(manager.getDefinition(

                        AbstractVectorialLegend.VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME));

                definition.addDynFieldList(COMPLEX_LEGEND_FIELD).setClassOfItems(DefaultComplexLegendItem.class);

                definition.addDynFieldBoolean("allowOverlay");

            }

            return Boolean.TRUE;

        }

    }

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        super.loadFromState(state);

        try {

            this.allowOverlap = state.getBoolean("allowOverlay");

        } catch (Exception e) {

            this.allowOverlap = false;

        }

        setLegends(state.getList(COMPLEX_LEGEND_FIELD));

    }

    private void setLegends(List list) {

        this.legends = list;

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("allowOverlay", this.allowOverlap);

        state.set(COMPLEX_LEGEND_FIELD, getEditedLegends());

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager = MapContextLocator.getMapContextManager();

            manager.registerLegend(

                    COMPLEX_LEGEND_NAME,

                    DefaultVectorComplexLegend.class);

            return Boolean.TRUE;

        }

    }

    public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

        if (this.getCurrentLegend() != null

                && this.getCurrentLegend() instanceof IVectorLegend) {

            return ((IVectorLegend) this.getCurrentLegend()).getSymbolByFeature(feat);

        }

        return null;

    }

    public int getShapeType() {

        return this.shapeType;

    }

    public void setShapeType(int shapeType) {

        this.shapeType = shapeType;

        SymbolManager manager = MapContextLocator.getSymbolManager();

        this.defaultSymbol = manager.createSymbol(shapeType);

    }

    public void setDefaultSymbol(ISymbol s) {

        this.defaultSymbol = s;

    }

    public boolean isUseDefaultSymbol() {

        return useDefault;

    }

    public void useDefaultSymbol(boolean b) {

        this.useDefault = b;

    }

    public boolean isSuitableForShapeType(int shapeType) {

        return true;

    }

    public ISymbol getDefaultSymbol() {

        return defaultSymbol;

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(

            FeatureStore featureStore) throws DataException {

        // TODO Auto-generated method stub

        return null;

    }

    public String[] getDescriptions() {

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

        for (ComplexLegendItem legend : this.legends) {

            if (legend != null) {

                if (legend.getLegend() != null

                        && legend.getLegend() instanceof AbstractVectorialLegend) {

                    if (legend.getLegend() instanceof IClassifiedLegend) {

                        String[] classifiedDescriptions = ((IClassifiedLegend) legend.getLegend()).getDescriptions();

                        for (String description : classifiedDescriptions) {

                            descriptions.add(description);

                        }

                    } else {

                        descriptions.add(null);

                    }

                }

            }

        }

        if (descriptions.isEmpty()) {

            descriptions.add(null);

        }

        return descriptions.toArray(new String[0]);

    }

    public ISymbol[] getSymbols() {

        List<ISymbol> symbols = new ArrayList<ISymbol>();

        for (ComplexLegendItem legend : this.legends) {

            if (legend != null) {

                if (legend.getLegend() != null

                        && legend.getLegend() instanceof AbstractVectorialLegend) {

                    if (legend.getLegend() instanceof IHasImageLegend) {

                        symbols.add(new SimpleImageMarkerSymbol((IHasImageLegend) legend.getLegend()));

                    } else if (legend.getLegend() instanceof IClassifiedLegend) {

                        ISymbol[] classifiedSymbols = ((IClassifiedLegend) legend.getLegend()).getSymbols();

                        for (ISymbol classifiedSymbol : classifiedSymbols) {

                            symbols.add(classifiedSymbol);

                        }

                    } else {

                        symbols.add(((IVectorLegend) legend.getLegend()).getDefaultSymbol());

                    }

                }

            }

        }

        if (symbols.isEmpty()) {

            if (getDefaultSymbol() != null) {

                symbols.add(getDefaultSymbol());

            } else {

                SymbolManager manager = MapContextLocator.getSymbolManager();

                symbols.add(manager.createSymbol(shapeType));

            }

        }

        return symbols.toArray(new ISymbol[0]);

    }

    public Object[] getValues() {

        List<Object> values = new ArrayList<Object>();

        for (ComplexLegendItem legend : this.legends) {

            if (legend != null) {

                if (legend.getLegend() != null

                        && legend.getLegend() instanceof AbstractVectorialLegend) {

                    if (legend.getLegend() instanceof IClassifiedLegend) {

                        Object[] classifiedValues = ((IClassifiedLegend) legend).getValues();

                        for (Object classifiedValue : classifiedValues) {

                            values.add(classifiedValue);

                        }

                    } else {

                        values.add(null);

                    }

                }

            }

        }

        if (values.isEmpty()) {

            values.add(null);

        }

        return values.toArray(new Object[0]);

    }

    private static class ComplexLegendChangedEvent extends SymbolLegendEvent {

        public ComplexLegendChangedEvent() {

            super(null, null);

        }

        @Override

        public int getEventType() {

            return SymbolLegendEvent.LEGEND_VALUE_CHANGED;

        }

    }

    private static class SimpleImageMarkerSymbol extends SimpleMarkerSymbol {

        private final IHasImageLegend legend;

        public SimpleImageMarkerSymbol(IHasImageLegend legend) {

            this.legend = legend;

        }

        @Override

        public void draw(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature feature, Cancellable cancel) {

            g.drawImage(this.legend.getImageLegend(), 0, 0, null);

        }

        @Override

        public double getSize() {

            return this.legend.getImageLegend().getWidth(null);

        }

    }

}

/* 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.complexlegend.impl;

import org.gvsig.complexlabel.impl.ComplexLabelClassFactory;

import org.gvsig.complexlabel.impl.DefaultComplexLabelClass;

import org.gvsig.complexlegend.ComplexLegendLibrary;

import org.gvsig.complexlegend.VectorComplexLegend;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.driver.impl.PersistenceBasedLegendWriter;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.util.Caller;

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

/**

 * Library for default implementation initialization and configuration.

 * This default implementation will be based in JFreeChart library.

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultComplexLegendLibrary extends AbstractLibrary {

	@Override

	public void doRegistration() {

		registerAsImplementationOf(ComplexLegendLibrary.class);

	}

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        Caller caller = new DefaultCaller();

        caller.add(new DefaultVectorComplexLegend.RegisterLegend());

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

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

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

        if( !caller.call() ) {

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

        }

        MapContextManager mcoman = MapContextLocator.getMapContextManager();

        mcoman.registerLegendWriter(

        	VectorComplexLegend.class,

            SymbolManager.LEGEND_FILE_EXTENSION.substring(1),

            PersistenceBasedLegendWriter.class);

        SymbologyLocator.getSymbologyManager().registerLabelClass(new ComplexLabelClassFactory());

    }

}

package org.gvsig.complexlegend.impl;

import java.util.Iterator;

import java.util.List;

import org.gvsig.app.project.documents.view.legend.gui.AbstractParentPanel;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.symbology.swing.SymbologySwingLocator;

public class ComplexLegendUtils {

	public static ILegendPanel getLegendPanel(ILegend legend){

		List panels = SymbologySwingLocator.getSwingManager().getLegendEditorClasses();

		Iterator it = panels.iterator();

		while(it.hasNext()){

			Class panelClass = (Class) it.next();

			ILegendPanel panel;

			try {

				panel = (ILegendPanel) panelClass.newInstance();

				if(!(panel instanceof AbstractParentPanel)){

					if(panel.getLegendClass().equals(legend.getClass())){

						return panel;

					}

				}

			} catch (Exception e) {

				return null;

			}

		}

		return null;

	}

}

package org.gvsig.complexlegend.impl;

import java.text.NumberFormat;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.complexlegend.ComplexLegendItem;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultComplexLegendItem implements ComplexLegendItem, Persistent {

    public static final Logger logger = LoggerFactory.getLogger(DefaultComplexLegendItem.class);

    public static final String COMPLEX_LEGEND_ITEM_PERSISTENCE_DEFINITION_NAME = "ComplexLegendItem";

    private ILegend legend;

    private double maxScale;

    private double minScale;

    public ILegend getLegend() {

        return legend;

    }

    public void setLegend(ILegend legend) {

        this.legend = legend;

    }

    public double getMaxScale() {

        return maxScale;

    }

    public void setMaxScale(double maxScale) {

        this.maxScale = maxScale;

    }

    public double getMinScale() {

        return minScale;

    }

    public void setMinScale(double minScale) {

        this.minScale = minScale;

    }

    public String toString() {

        String panel = "";

        if (legend != null) {

            ILegendPanel legPanel = ComplexLegendUtils.getLegendPanel(legend);

            if (legPanel != null) {

                panel = " " + legPanel.getTitle();

            }

        }

        Double mind = (Double) getMinScale();

        String min = "0";

        if (mind >= 0) {

            int mini = mind.intValue();

            min = NumberFormat.getIntegerInstance().format(mini);

        }

        Double maxd = (Double) getMaxScale();

        String max = "inf";

        if (maxd >= 0) {

            int maxi = maxd.intValue();

            max = NumberFormat.getIntegerInstance().format(maxi);

        }

        return "[1:" + min + " - 1:" + max + "]" + panel;

    }

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set own properties

        setLegend((ILegend) state.get("legend"));

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

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

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save own properties

        state.set("legend", getLegend());

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

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

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                    COMPLEX_LEGEND_ITEM_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        DefaultComplexLegendItem.class,

                        COMPLEX_LEGEND_ITEM_PERSISTENCE_DEFINITION_NAME,

                        COMPLEX_LEGEND_ITEM_PERSISTENCE_DEFINITION_NAME

                        + " Persistence definition",

                        null,

                        null

                );

                definition.addDynFieldObject("legend").setMandatory(true)

                        .setClassOfValue(ILegend.class);

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

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

            }

            return Boolean.TRUE;

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultComplexLegendItem cloned = (DefaultComplexLegendItem) super.clone(); //To change body of generated methods, choose Tools | Templates.

        cloned.legend = (ILegend) this.legend.clone();

        return cloned;

    }

}

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;

		}

	}

}

package org.gvsig.complexlabel.impl;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelClass;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelClassFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

public class ComplexLabelClassFactory implements ILabelClassFactory {

	public static final String FACTORY_ID = "MultipleLabelByScale";

	I18nManager i18nManager = ToolsLocator.getI18nManager();

	public ILabelClass create() {

		return new DefaultComplexLabelClass();

	}

	public String getID() {

		return FACTORY_ID;

	}

	public String getName() {

		return i18nManager.getTranslation("multiple_label_by_scale");

	}

	public String toString() {

		return this.getName();

	}

}

<?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 library API default implementation.</p>

</body>

</html>

org.gvsig.complexlegend.impl.DefaultComplexLegendLibrary