| gvSIG desktop 1

package org.gvsig.fmap.mapcontrol.tools;

import java.awt.geom.Point2D;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

public class AreaListenerTest extends AbstractLibraryAutoInitTestCase {

	private IProjection projectionUTM = CRSFactory.getCRS("EPSG:23030");

	private IProjection projectionGeo = CRSFactory.getCRS("EPSG:4230");

	@Override

	protected void doSetUp() throws Exception {

		// Nothing to do	

	}

	public void test1() {

		AreaListenerImpl areaListenerUTM=new AreaListenerImpl(newMapControlUTM());

		AreaListenerImpl areaListenerGeo=new AreaListenerImpl(newMapControlGeo());

		Double[] xsUTM=new Double[] {new Double(731292),new Double(731901),new Double(730138)};

		Double[] ysUTM=new Double[] {new Double(4351223),new Double(4350768),new Double(4349232)};

		double areaUTM=areaListenerUTM.returnCoordsArea(xsUTM,ysUTM,new Point2D.Double(730138,4349232));

		Double[] xsGeo=new Double[] {new Double(-0.31888183),new Double(-0.31173131),new Double(-0.33268401)};

		Double[] ysGeo=new Double[] {new Double(39.27871741),new Double(39.27464327),new Double(39.26117368)};

		double areaGeo=areaListenerGeo.returnGeoCArea(xsGeo,ysGeo,new Point2D.Double(-0.33268401,39.26117368));

		assertTrue("Area UTM igual a Geo",areaUTM<(areaGeo+1000)&& areaUTM>(areaGeo-1000));

	}

	private MapControl newMapControlUTM() {

		ViewPort vp = new ViewPort(projectionUTM);

		MapControl mc=new MapControl();

		mc.setMapContext(new MapContext(vp));

		return mc;

	}

	private MapControl newMapControlGeo() {

		ViewPort vp = new ViewPort(projectionGeo);

		MapControl mc=new MapControl();

		mc.setMapContext(new MapContext(vp));

		return mc;

	}

}

/* 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.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 IVER T.I. S.A.   {{Task}}

 */

/**

 *

 */

package org.gvsig.fmap.mapcontrol.swing.dynobject;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.i18n.Messages;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.dynobject.JDynObjectComponent;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

/**

 * Editor for a store parameters.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DynObjectEditor extends JPanel implements ActionListener {

    private static final long serialVersionUID = 23898787077741411L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DynObjectEditor.class);

    private static final WindowManager WINDOW_MANAGER =

        ToolsSwingLocator.getWindowManager();

    private String title;

    private JButton botAcept;

    private JButton botCancel;

    private JButton botRestoreDefaults;

    private JPanel panButtons;

    private boolean modal;

    private JDynObjectComponent component;

    public DynObjectEditor(DynObject parameters) throws ServiceException {

        component =

            ToolsSwingLocator.getDynObjectSwingManager()

                .createJDynObjectComponent(parameters, true);

        this.setLayout(new BorderLayout());

        this.add(component.asJComponent(), BorderLayout.CENTER);

        this.add(getButtonsPanel(), BorderLayout.SOUTH);

    }

    private JPanel getButtonsPanel() {

        if (this.panButtons == null) {

            this.panButtons = new JPanel();

            this.panButtons.setLayout(new GridBagLayout());

            GridBagConstraints constr = new GridBagConstraints();

            constr.anchor = GridBagConstraints.LAST_LINE_END;

            constr.fill = GridBagConstraints.HORIZONTAL;

            constr.weightx = 1;

            constr.weighty = 0;

            this.panButtons.add(new JLabel(), constr);

            constr = this.getDefaultParametersConstraints();

            constr.fill = GridBagConstraints.NONE;

            constr.weightx = 0;

            constr.weighty = 0;

            this.panButtons.add(this.getAcceptButton(), constr);

            this.panButtons.add(this.getCancelButton(), constr);

            this.panButtons.add(this.getRestoreDefaults(), constr);

        }

        return this.panButtons;

    }

    private GridBagConstraints getDefaultParametersConstraints() {

        GridBagConstraints constr = new GridBagConstraints();

        constr.insets = new Insets(2, 2, 2, 2);

        constr.ipadx = 2;

        constr.ipady = 2;

        constr.anchor = GridBagConstraints.PAGE_START;

        return constr;

    }

    private JButton getRestoreDefaults() {

        if (this.botRestoreDefaults == null) {

            this.botRestoreDefaults =

                ToolsSwingLocator.getUsabilitySwingManager().createJButton(

                    Messages.getText("restoreDefaults"));

            this.botRestoreDefaults.addActionListener(this);

        }

        return this.botRestoreDefaults;

    }

    private JButton getCancelButton() {

        if (this.botCancel == null) {

            this.botCancel =

                ToolsSwingLocator.getUsabilitySwingManager().createJButton(

                    Messages.getText("cancel"));

            this.botCancel.addActionListener(this);

        }

        return this.botCancel;

    }

    private JButton getAcceptButton() {

        if (this.botAcept == null) {

            this.botAcept =

                ToolsSwingLocator.getUsabilitySwingManager().createJButton(

                    Messages.getText("accept"));

            this.botAcept.addActionListener(this);

        }

        return this.botAcept;

    }

    public void actionPerformed(ActionEvent e) {

        Component source = (Component) e.getSource();

        if (source == this.botAcept) {

            this.component.saveStatus();

            this.closeWindow();

        } else

            if (source == this.botCancel) {

                // TODO Close windows

                this.closeWindow();

            } else

                if (source == this.botRestoreDefaults) {

                    // TODO: implement

                    // this.component.restore();

                }

    }

    protected void closeWindow() {

        LOG.debug("Closing window, values edited: ", component.getDynObject());

        this.setVisible(false);       

    }

    public void editObject(boolean modal) {

        this.modal = modal;

        WINDOW_MANAGER.showWindow(this, 

            Messages.getText("explorer_parameters"), 

            WindowManager.MODE.DIALOG);

    }

    public String getTitle() {

        return title;

    }

    public void setTitle(String title) {

        this.title = title;

    }

    public DynObject getParameters() {

        return component.getDynObject();

    }

}

/* 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.fmap.mapcontrol.swing.dynobject;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.swing.api.Component;

/**

 * Interface for components to show information of a list of layers.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public interface LayersDynObjectSetComponent extends Component, Disposable {

}

/* 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.fmap.mapcontrol.swing.dynobject.impl;

import java.awt.BorderLayout;

import java.util.Map;

import javax.swing.JComponent;

import javax.swing.JList;

import javax.swing.JPanel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.mapcontrol.swing.dynobject.LayersDynObjectSetComponent;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.dynobject.set.JDynObjectSetComponent;

/**

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class DefaultLayersDynObjectSetComponent extends JPanel implements

    LayersDynObjectSetComponent, ListSelectionListener {

    private static final long serialVersionUID = 5864674721657215264L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultLayersDynObjectSetComponent.class);

    private final LayersDynObjectSetComponentModel model;

    private JDynObjectSetComponent component;

    private JList layersList;

    private final boolean writable;

    /**

     * Creates a new {@link DefaultLayersDynObjectSetComponent} with the given

     * information for a list of layers.

     */

    public DefaultLayersDynObjectSetComponent(

        Map<String, DynObjectSet> layerName2InfoByPoint) {

        this(layerName2InfoByPoint, true);

    }

    /**

     * @param isDoubleBuffered

     */

    public DefaultLayersDynObjectSetComponent(

        Map<String, DynObjectSet> layerName2InfoByPoint,

 boolean writable) {

        super(new BorderLayout());

        this.writable = writable;

        model = new LayersDynObjectSetComponentModel(layerName2InfoByPoint);

        initializeUI();

    }

    private void initializeUI() {

        addLayerList();

    }

    private void addLayerList() {

        layersList = new JList(model);

        layersList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        layersList.setLayoutOrientation(JList.VERTICAL);

        // list.setVisibleRowCount(20);

        layersList.addListSelectionListener(this);

        add(layersList, BorderLayout.WEST);

        layersList.setSelectedIndex(0);

    }

    public void valueChanged(ListSelectionEvent e) {

        if (!e.getValueIsAdjusting()) {

            String layerName = (String) layersList.getSelectedValue();

            setCurrentLayerInfoByPoint(layerName);

        }

    }

    private void setCurrentLayerInfoByPoint(String layerName) {

        JDynObjectSetComponent newComponent = null;

        DynObjectSet dynObjectSet = model.getLayerInfoByPoint(layerName);

        try {

            newComponent =

                ToolsSwingLocator.getDynObjectSwingManager()

                    .createJDynObjectSetComponent(dynObjectSet, writable);

        } catch (BaseException e) {

            LOG.error("Error creating the JDynObjectSetComponent for "

                + "the DynObjectSet: " + dynObjectSet, e);

        }

        if (newComponent != null) {

            removeCurrentDynObjectSetComponent();

            component = newComponent;

            add(component.asJComponent(), BorderLayout.CENTER);

            revalidate();

            repaint();

        }

    }

    public JComponent asJComponent() {

        return this;

    }

    public void dispose() {

        removeCurrentDynObjectSetComponent();

        model.dispose();

    }

    private void removeCurrentDynObjectSetComponent() {

        if (component != null) {

            remove(component.asJComponent());

            component.dispose();

        }

    }

}

/* 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.fmap.mapcontrol.swing.dynobject.impl;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import javax.swing.AbstractListModel;

import org.gvsig.fmap.mapcontrol.swing.dynobject.LayersDynObjectSetComponent;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dynobject.DynObjectSet;

/**

 * Model for a {@link LayersDynObjectSetComponent}.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class LayersDynObjectSetComponentModel extends AbstractListModel

    implements Disposable {

    private static final long serialVersionUID = -7978388308830573063L;

    private final Map<String, DynObjectSet> layerName2InfoByPoint;

    private final String[] layerNames;

    public LayersDynObjectSetComponentModel(

        Map<String, DynObjectSet> layerName2InfoByPoint) {

        this.layerName2InfoByPoint = layerName2InfoByPoint;

        Set<String> keyset = layerName2InfoByPoint.keySet();

        layerNames = keyset.toArray(new String[keyset.size()]);

    }

    public String[] getLayerNames() {

        Set<String> keyset = layerName2InfoByPoint.keySet();

        return keyset.toArray(new String[keyset.size()]);

    }

    public DynObjectSet getLayerInfoByPoint(String layerName) {

        return layerName2InfoByPoint.get(layerName);

    }

    public int getSize() {

        return layerName2InfoByPoint.size();

    }

    public Object getElementAt(int index) {

        return layerNames[index];

    }

    public void dispose() {

        for (Iterator<DynObjectSet> iterator =

            layerName2InfoByPoint.values().iterator(); iterator.hasNext();) {

            iterator.next().dispose();

        }

        layerName2InfoByPoint.clear();

    }

}

/* 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.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.mapcontrol.swing.dynobject;

import java.awt.Color;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

import org.cresques.cts.IProjection;

import org.gvsig.i18n.Messages;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

public class DynObjectViewer extends JPanel {

	/**

	 *

	 */

	private static final long serialVersionUID = -5277036770491043233L;

	private GridBagConstraints paramsListLabelConstraint;

	private GridBagConstraints paramsListValueConstraint;

	private GridBagConstraints paramsListFillConstraint;

	public DynObjectViewer() {

		super();

		this.intialize();

	}

	private void intialize() {

		this.setLayout(new GridBagLayout());

		paramsListLabelConstraint = new GridBagConstraints();

		paramsListValueConstraint = new GridBagConstraints();

		paramsListFillConstraint = new GridBagConstraints();

		paramsListLabelConstraint.ipadx = 3;

		paramsListLabelConstraint.ipady = 3;

		paramsListLabelConstraint.anchor = GridBagConstraints.FIRST_LINE_START;

		paramsListLabelConstraint.gridwidth = GridBagConstraints.RELATIVE;

		paramsListLabelConstraint.fill = GridBagConstraints.HORIZONTAL;

		paramsListLabelConstraint.weightx = 0.5;

		paramsListValueConstraint.ipadx = 3;

		paramsListValueConstraint.ipady = 3;

		paramsListValueConstraint.anchor = GridBagConstraints.FIRST_LINE_END;

		paramsListValueConstraint.gridwidth = GridBagConstraints.REMAINDER;

		paramsListValueConstraint.fill = GridBagConstraints.HORIZONTAL;

		paramsListValueConstraint.weightx = 0.5;

		paramsListFillConstraint.ipadx = 3;

		paramsListFillConstraint.ipady = 3;

		paramsListFillConstraint.anchor = GridBagConstraints.FIRST_LINE_END;

		paramsListFillConstraint.gridwidth = GridBagConstraints.REMAINDER;

		paramsListFillConstraint.fill = GridBagConstraints.BOTH;

		paramsListFillConstraint.weightx = 1;

		paramsListFillConstraint.weighty = 1;

	}

	private String getLocalizedText(String txt) {

		try {

			return Messages.getText(txt);

		} catch (Exception e) {

			return txt;

		}

	}

	public void load(DynObject dynObj) {

		this.removeAll();

		if (dynObj == null) {

			this.doLayout();

			return;

		}

		DynClass dynClass = dynObj.getDynClass();

		JTextField label;

		JTextField text;

		Object value;

		String strValue;

		//		label = new JLabel();

		//		label.setText(getLocalizedText("parameter"));

		//		label.setBackground(Color.LIGHT_GRAY);

		//		this.add(label, paramsListLabelConstraint);

		text = new JTextField();

		text.setText(getLocalizedText("parameter"));

		text.setEditable(false);

		text.setBackground(Color.LIGHT_GRAY);

		this.add(text, paramsListLabelConstraint);

		text = new JTextField();

		text.setText(getLocalizedText("value"));

		text.setEditable(false);

		text.setBackground(Color.LIGHT_GRAY);

		this.add(text, paramsListValueConstraint);

		for (DynField field : dynClass.getDynFields()) {

			label = new JTextField();

			label.setText(field.getDescription());

			label.setEditable(false);

			this.add(label, paramsListLabelConstraint);

			strValue = "";

			value = dynObj.getDynValue(field.getName());

			if (value != null) {

				if (value instanceof String) {

					strValue = (String) value;

				} else if (value instanceof IProjection) {

					strValue = ((IProjection) value).getAbrev();

				} else {

					strValue = value.toString();

				}

			}

			text = new JTextField();

			text.setText(strValue);

			text.setEditable(false);

			this.add(text, paramsListValueConstraint);

		}

		this.add(new JLabel(), paramsListFillConstraint);

		this.doLayout();

		this.repaint();

	}

}

/* 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.

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.mapcontrol;

import java.util.Map;

import java.util.prefs.Preferences;

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

import org.gvsig.fmap.mapcontrol.swing.dynobject.LayersDynObjectSetComponent;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapper;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectSet;

/**

 * <p>

 * This class is the manager of the MapControl library. It is used to

 * manage all the properties related with the drawing of objects 

 * in a map, including default symbols used to draw objects

 * in a map, the tolerance used by the selection or edition tools...

 * </p>

 * <p>

 * It also holds the implementations of the {@link MapControlDrawer}'s, 

 * that is the responsible to draw graphical objects in a map.

 * </p> 

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public interface MapControlManager {

	public MapControl createJMapControlPanel() throws MapControlCreationException;

	/**

	 * Register a <code>MapControlDrawer</code> by name.

	 * @param name

	 * Name of the <code>MapControlDrawer</code>.

	 * @param mapControolDrawerClass

	 * Class used to draw graphical objects on a map.

	 */

	public void registerMapControlDrawer(String name, Class mapControolDrawerClass);

	/**

	 * Creates a <code>MapControlDrawer</code> from a name.

	 * @param name

	 * Name of the <code>MapControlDrawer</code>.

	 * @return

	 * A <code>MapControlDrawer</code>.

	 * @throws MapControlCreationException

	 */

	public MapControlDrawer createMapControlDrawer(String name) throws MapControlCreationException;

	/**

	 * It registers the default implementation for the <code>MapControlDrawer</code>.

	 * @param mapControlDrawerClass

	 * A <code>MapControlDrawer</code>. 

	 */

	public void registerDefaultMapControlDrawer(Class mapControlDrawerClass);

	/**

	 * It returns the default implementation for the <code>MapControlDrawer</code>.

	 * @return

	 * The default <code>MapControlDrawer</code>.

	 * @throws MapControlCreationException

	 */

	public MapControlDrawer createDefaultMapControlDrawer() throws MapControlCreationException;

	/**

	 * Returns a snapper in a concrete position;

	 * @param index

	 * Snapper position.

	 * @return

	 * A snapper. 

	 */

	public ISnapper getSnapperAt(int index);

	/**

	 * Returns the number of registered snappers.

	 * @return

	 * The number of registered snappers.

	 */

	public int getSnapperCount();

	/**

	 * Add a snapper.

	 * @param snapper

	 */

	public void registerSnapper(String name, Class snapperClass);

	public Preferences getEditionPreferences();

	/**

	 * Tolerance (in pixels) that has to be used by the tools

	 * that use snapping.

	 * @return

	 * The distance in pixels.

	 */

	public int getTolerance();

	/**

	 * Sets the tolerance (in pixels) that has to be used by the

	 * tools that use snapping.

	 * @param tolerance

	 * The tolerance to apply

	 */

	public void setTolerance(int tolerance);

	/**

	 * Sets the symbol that has to be used to draw a geometry when

	 * it is selected.

	 * @param selectionSymbol

	 * The symbol to apply.

	 * @deprecated the symbol for edition is the selection symbol

	 */

	public void setSelectionSymbol(ISymbol selectionSymbol);

	/**

	 * Gets the symbol used to draw the selected geometries.

	 * @return

	 * The symbol used to draw the selected geometries.

	 * @deprecated the symbol for edition is the selection symbol

	 */

	public ISymbol getSelectionSymbol();

	/**

	 * Sets the symbol that has to be used to draw a geometry that

	 * represent the axis of a geometry.

	 * @param axisReferencesSymbol

	 * The symbol to apply.

	 */

	public void setAxisReferenceSymbol(ISymbol axisReferencesSymbol);

	/**

	 * Gets the symbol used to draw the axis of a geometry.

	 * @return

	 * The symbol used to draw the axis of a geometry.

	 */

	public ISymbol getAxisReferenceSymbol();

	/**

	 * Sets the symbol that has to be used to draw a geometry when

	 * it is selected.

	 * @param geometrySelectionSymbol

	 * The symbol to apply.

	 */

	public void setGeometrySelectionSymbol(ISymbol geometrySelectionSymbol);

	/**

	 * Gets the symbol used to draw the selected geometries.

	 * @return

	 * The symbol used to draw the selected geometries.

	 */

	public ISymbol getGeometrySelectionSymbol();

	/**

	 * Sets the symbol that has to be used to draw the handlers.

	 * @param handlerSymbol

	 * The symbol to apply.

	 */

	public void setHandlerSymbol(ISymbol handlerSymbol);

	/**

	 * Gets the symbol used to draw the handlers.

	 * @return

	 * The symbol used to draw the handlers.

	 */

	public ISymbol getHandlerSymbol();

    /**

     * Creates a readonly component to view information of a set of layers. The

     * information must be provided as a set of {@link DynObject}s, through a

     * {@link DynObjectSet}.

     * 

     * @param layerName2InfoByPoint

     *            the map of {@link DynObjectSet} for each layer.

     * @return the component to view the information

     */

    public LayersDynObjectSetComponent createLayersDynObjectSetComponent(

        Map<String, DynObjectSet> layerName2InfoByPoint);

    /**

     * Creates a component to view information of a set of layers. The

     * information must be provided as a set of {@link DynObject}s, through a

     * {@link DynObjectSet}.

     * 

     * @param layerName2InfoByPoint

     *            the map of {@link DynObjectSet} for each layer.

     * @param writable

     *            if the DynObjects loaded must be able to be edited

     * @return the component to view the information

     */

    public LayersDynObjectSetComponent createLayersDynObjectSetComponent(

        Map<String, DynObjectSet> layerName2InfoByPoint, boolean writable);

}

/* 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.

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.mapcontrol;

import org.gvsig.tools.exception.BaseException;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class MapControlException extends BaseException {

	private static final long serialVersionUID = 981894833703125550L;

	/**

     * @see BaseException#BaseException(String, String, long)

     */

    public MapControlException(String message, String key, long code) {

        super(message, key, code);

    }

    /**

     * @see BaseException#BaseException(String, Throwable, String, long)

     */

    public MapControlException(String message, Throwable cause, String key,

            long code) {

        super(message, cause, key, code);

    }

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.fmap.mapcontrol;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.event.MouseWheelEvent;

import java.awt.event.MouseWheelListener;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import java.util.TreeMap;

import java.util.prefs.Preferences;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataStoreNotification;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.util.Converter;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.events.AtomicEvent;

import org.gvsig.fmap.mapcontext.events.listeners.AtomicEventListener;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.LayerCollectionEvent;

import org.gvsig.fmap.mapcontext.layers.LayerEvent;

import org.gvsig.fmap.mapcontext.layers.SpatialCache;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.GraphicLayer;

import org.gvsig.fmap.mapcontrol.tools.BehaviorException;

import org.gvsig.fmap.mapcontrol.tools.CompoundBehavior;

import org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior;

import org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener;

import org.gvsig.fmap.mapcontrol.tools.grid.Grid;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapper;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperGeometriesVectorial;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperRaster;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperVectorial;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.utils.exceptionHandling.ExceptionHandlingSupport;

import org.gvsig.utils.exceptionHandling.ExceptionListener;

/**

 * <p>

 * A component that includes a {@link MapContext MapContext} with support for

 * use it as a particular {@link Behavior Behavior}.

 * </p>

 * 

 * <p>

 * A developer can register a set of <code>Behavior</code>, but only one (that

 * can be a composition of several) of them can be active. The active one

 * defines the way to work and access with its <code>MapContext</code>'s layers.

 * The active behavior, in combination with the appropriate {@link ToolListener

 * ToolListener} will allow user work with a particular <i>tool</i>.

 * </p>

 * 

 * <p>

 * All mouse events produced on this component will be delegated to the current

 * active behavior, the <i>currentMapTool</i>.

 * </p>

 * 

 * <p>

 * <b>Drawing process:</b>

 * </p>

 * 

 * <p>

 * Uses a double buffer for the drawing process of <code>MapContext</code>'s

 * information.

 * </p>

 * 

 * <p>

 * If the double buffer wasn't created, creates a new one.

 * </p>

 * 

 * <p>

 * Paints the component according the following algorithm: <br>

 * &nbsp If <i>status</i> is <i>UPDATED</i>:<br>

 * &nbsp &nbsp If there is a <i>double buffer</i>:<br>

 * &nbsp &nbsp &nbsp If there is a <i>behavior</i> for managing the

 * <code>MapControl</code> instance, delegates the drawing process to that

 * behavior, calling: <code><i>behavior_instance</i>.paintComponent(g)</code>.<br>

 * &nbsp &nbsp &nbsp Else, repaints the current graphical information quickly

 * calling: <code>g.drawImage(image,0,0,null)</code>.<br>

 * &nbsp Else, (<i>status</i> is <i>OUTDATED</i>, or <i>ONLY_GRAPHICS</i>):

 * executes a quickly repaint of the previous information calling

 * <code>g.drawImage(image,0,0,null)</code>, and creates a <i>painting

 * request</i> to delegate the heavy drawing process to the {@link Drawer2

 * Drawer2}'s worker thread, according the <i>SingleWorketThread</i> pattern,

 * starting a timer to update (invoking <code>repaint()</code>) the view every

 * delay of <code>1000 / drawFrameRate</code> ms. during that heavy drawing

 * process, and if its enabled <code>drawAnimationEnabled</code>. The

 * <i>painting request</i> once is being attended, invokes

 * <code>MapContext</code> to draw the layers:

 * <code>mapContext.draw(image, g, cancel,mapContext.getScaleView());</code>

 * <br>

 * <p>

 * Some notes:

 * <ul>

 * <li>The painting process can be cancelled calling {@link #cancelDrawing()

 * #cancelDrawing()}.</li>

 * <li>At last resort, the particular implementation of each layer in a

 * <code>MapControl</code>'s <code>MapContrext</code> will be that one which

 * will draw the graphical information, and, if supports, which could cancel its

 * drawing subprocess.</li>

 * <li>It's possible to force repaint all layers, calling

 * {@link #drawMap(boolean doClear) #drawMap(boolean)}.</li>

 * <li>It's possible repaint only the dirty layers, calling

 * {@link #rePaintDirtyLayers() #rePaintDirtyLayers()}.</li>

 * <li>It's possible repaint only the {@link GraphicLayer GraphicLayer}, calling

 * {@link #drawGraphics() #drawGraphics()}.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Tools:</b>

 * </p>

 * 

 * <p>

 * A developer can:

 * <ul>

 * <li>Register each tool as:

 * <ul>

 * <li>A single behavior: {@link #addBehavior(String, Behavior)

 * #addMapTool(String, Behavior)}.</li>

 * <li>Or, a compound behavior: {@link #addBehavior(String, Behavior)

 * #addMapTool(String, Behavior)}.</li>

 * </ul>

 * </li>

 * <li>Get the current active tool: {@link #getCurrentMapTool()

 * #getCurrentMapTool()}.</li>

 * <li>Get the current active tool name: {@link #getCurrentTool()

 * #getCurrentTool()}.</li>

 * <li>Get a registered tool: {@link #getMapTool(String) #getMapTool(String)}.</li>

 * <li>Get the name of all tools registered: {@link #getMapToolsKeySet()

 * #getMapToolsKeySet()}.</li>

 * <li>Get all tools registered, including the name they were registered:

 * {@link #getNamesMapTools() #getNamesMapTools()}.</li>

 * <li>Determine if has a tool registered: {@link #hasTool(String)

 * #hasTool(String)}.</li>

 * <li>Set as an active tool, one of the registered: {@link #setTool(String)

 * #setTool(String)}.</li>

 * <li>Set as active tool, the previous used: {@link #setPrevTool()

 * #setPrevTool()}.</li>

 * <li>Set the current tool: {@link #setCurrentMapTool(Behavior)

 * #setCurrentMapTool(Behavior)}.</li>

 * <li>Change the draw frame rate: {@link #setDrawFrameRate(int)

 * #setDrawFrameRate(int)} and {@link #applyFrameRate() #applyFrameRate()}.</li>

 * <li>Get the draw frame rate: {@link #getDrawFrameRate() #getDrawFrameRate()}.

 * </li>

 * <li>Determine if will repaint this component each time timer finishes:

 * {@link #isDrawAnimationEnabled() #isDrawAnimationEnabled()}.</li>

 * <li>Change if will repaint this component each time timer finishes:

 * {@link #setDrawAnimationEnabled(boolean) #setDrawAnimationEnabled(boolean)}.</li>

 * <li>Get the shared object that determines if a drawing process must be

 * cancelled or can continue: {@link #getCanceldraw() #getCanceldraw()}.</li>

 * <li>Get the combined tool: {@link #getCombinedTool() #getCombinedTool()}.</li>

 * <li>Set a combined tool: {@link #setCombinedTool(Behavior)

 * #setCombinedTool(Behavior)}.</li>

 * <li>Remove the combined tool: {@link #removeCombinedTool()

 * #removeCombinedTool()}.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Exception listener:</b>

 * </p>

 * 

 * <p>

 * Adding an <code>ExceptionListener</code>, can get notification about any

 * exception produced:

 * <ul>

 * <li>Attending a <i>painting request</i>.</li>

 * <li>Working with the active tool.</li>

 * <li>Applying a <i>zoom in</i> or <i>zoom out</i> operation.</li>

 * </ul>

 * </p>

 * 

 * <p>

 * <b>Other:</b>

 * </p>

 * 

 * <p>

 * Other useful capabilities of <code>MapControl</code>:

 * <ul>

 * <li>Cancel the current drawing process (notifying it also to the inner

 * <code>MapContext</code> instance and its layers): {@link #cancelDrawing()

 * #cancelDrawing()}.</li>

 * <li>Applying a <i>zoom in</i> operation centered at mouse position (without a

 * <code>ToolListener</code>): {@link #zoomIn() #zoomIn()}.</li>

 * <li>Applying a <i>zoom out</i> operation centered at mouse position (without

 * a <code>ToolListener</code>): {@link #zoomOut() #zoomOut()}.</li>

 * </ul>

 * </p>

 * 

 * @see CancelDraw

 * @see Drawer

 * @see MapContextListener

 * @see MapToolListener

 * 

 * @author Fernando Gonz?lez Cort?s

 * @author Pablo Piqueras Bartolom? (pablo.piqueras@iver.es)

 */

public class MapControl extends JComponent implements ComponentListener,

    Observer {

    protected static final GeometryManager geomManager =

        GeometryLocator.getGeometryManager();

    protected static final Logger logger =

        LoggerFactory.getLogger(GeometryManager.class);

    /**

     * <p>

     * One of the possible status of <code>MapControl</code>. Determines that

     * all visible information has been drawn and its updated.

     * </p>

     */

    public static final int ACTUALIZADO = 0;

    /**

     * <p>

     * One of the possible status of <code>MapControl</code>. Determines that

     * not all visible information has been drawn or isn't updated.

     * </p>

     */

    public static final int DESACTUALIZADO = 1;

    /**

     * <p>

     * Determines if the drawer can update this <code>MapControl</code> instance

     * when the timer launches an event.

     * </p>

     */

    private static boolean drawAnimationEnabled = true;

    /**

     * <p>

     * Inner model with the layers, event support for drawing them, and the

     * <code>ViewPort</code> with information to adapt to the bounds available

     * in <i>image coordinates</i>.

     * </p>

     * 

     * @see #getMapContext()

     * @see #setMapContext(MapContext)

     */

    private MapContext mapContext = null;

    /**

     * <p>

     * All registered <code>Behavior</code> that can define a way to work with

     * this <code>MapControl</code>.

     * </p>

     * 

     * <p>

     * Only one of them can be active at a given moment.

     * </p>

     * 

     * @see #addBehavior(String, Behavior)

     * @see #addBehavior(String, Behavior[])

     * @see #getMapTool(String)

     * @see #getMapToolsKeySet()

     * @see #getNamesMapTools()

     */

    protected HashMap namesMapTools = new HashMap();

    /**

     * <p>

     * Active {@link Behavior Behavior} that will generate events according a

     * criterion, and then, with a {@link ToolListener ToolListener} associated,

     * will simulate to user that works with this component as a particular

     * tool.

     * </p>

     * 

     * @see #getCurrentMapTool()

     * @see #getCurrentTool()

     * @see #setTool(String)

     */

    protected Behavior currentMapTool = null;

    /**

     * <p>

     * Determines which's the current drawn status of this component:

     * <ul>

     * <li><b>OUTDATED</b>: all visible information has been drawn or isn't

     * updated.</li>

     * <li><b>UTDATED</b>: all visible information has been drawn and its

     * updated.</li>

     * <li><b>ONLY_GRAPHICS</b>: only the graphical layer must be drawn /

     * updated.</li>

     * </ul>

     * </p>

     * 

     * <p>

     * The <code>MapControl</code> drawing process will consider the value of

     * this parameter to decide which elements will be updated or drawn.

     * </p>

     */

    private int status = DESACTUALIZADO;

    /**

     * <p>

     * Image with a buffer to accelerate the draw the changes of the graphical

     * items in this component.

     * </p>

     * 

     * <p>

     * Firstly, information will be drawn in the buffer, and, when is outright

     * drawn, that information will be displayed. Meanwhile, the previous image

     * can be kept showed.

     * </p>

     * 

     * @see BufferedImage

     * 

     * @see #getImage()

     */

    private BufferedImage image = null;

    /**

     * <p>

     * Name of the tool used currently to interact with this component.

     * </p>

     * 

     * @see #getCurrentTool()

     * @see #setTool(String)

     */

    protected String currentTool;

    /**

     * <p>

     * Object to store the flag that notifies a drawing thread task and

     * <code>MapContext</code>'s layers, that must be canceled or can continue

     * with the process.

     * </p>

     * 

     * @see #cancelDrawing()

     */

    private CancelDraw canceldraw;

    // private boolean isCancelled = true;

    /**

     * <p>

     * Fires an action events after a specified delay.

     * </p>

     * 

     * <p>

     * <code>MapControl</code> will use the timer to update its visible

     * graphical information during a drawing process, or allowing to cancel

     * that process.

     * </p>

     * 

     * <p>

     * This is very useful to pretend faster interactivity to user when

     * <code>MapControl</code> has lots of layers, and / or layers with heavy

     * graphical elements, that need a long time to finish drawing all its data.

     * </p>

     */

    private Timer timer;

    /**

     * <p>

     * Reference to the {@link ViewPort ViewPort} of the {@link MapContext

     * MapContext} of this component.

     * </p>

     * 

     * <p>

     * The view port once is created an instance of <code>MapControl</code>, is

     * obtained from the <i>EPSG:23030</i> projection, that's the default

     * projection for this component.

     * </p>

     * 

     * <p>

     * After, the view port will change adapting itself according the current

     * projection and the extent.

     * </p>

     * 

     * @see #getViewPort()

     * 

     * @see ViewPort

     */

    protected ViewPort vp;

    /**

     * <p>

     * Manager of all <code>MapControl</code> painting requests.

     * </p>

     */

    private Drawer drawer;

    /**

     * <p>

     * Listener of all kind of mouse events produced in this component.

     * </p>

     * 

     * <p>

     * Delegates each mouse event to the current map tool.

     * </p>

     * 

     * @see #addBehavior(String, Behavior)

     * @see #addBehavior(String, Behavior[])

     * @see #getMapTool(String)

     * @see #getMapToolsKeySet()

     * @see #getNamesMapTools()

     * @see #setTool(String)

     */

    protected MapToolListener mapToolListener = new MapToolListener();

    /**

     * <p>

     * Listener of all events produced in a this component's

     * <code>MapContext</code> object during an atomic period of time.

     * </p>

     */

    private MapContextListener mapContextListener = new MapContextListener();

    /**

     * <p>

     * Group of <code>ExceptionListener</code> that, in whatever moment could be

     * notified a Throwable Java error or exception.

     * </p>

     * 

     * @see #addExceptionListener(ExceptionListener)

     * @see #removeExceptionListener(ExceptionListener)