Application: gvSIG desktop

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.annotation">

		<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.annotation.impl;

import org.gvsig.annotation.AnnotationCreationService;

import org.gvsig.annotation.AnnotationCreationServiceTest;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

/**

 * {@link AnnotationCreationService} API compatibility tests for the

 * {@link DefaultAnnotationCreationService} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultAnnotationCreationServiceTest extends AnnotationCreationServiceTest {

	public DefaultAnnotationCreationServiceTest() {

		super();		

	}

	@Override

	public TextPointPairList getResult() throws CreateGeometryException {

		GeometryManager geometryManager = GeometryLocator.getGeometryManager();

		TextPointPairList textPointPairList = new TextPointPairList();

		textPointPairList.addPoint("Sevilla", geometryManager.createPoint(262760.53, 4146732.91, Geometry.SUBTYPES.GEOM2D));

		return textPointPairList;

	}

}

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

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.annotation.AnnotationCreationException;

import org.gvsig.annotation.AnnotationCreationFinishAction;

import org.gvsig.annotation.AnnotationCreationService;

import org.gvsig.annotation.AnnotationDataTypes;

import org.gvsig.annotation.AnnotationManager;

import org.gvsig.annotation.calculator.AnnotationPositionCalculationException;

import org.gvsig.annotation.calculator.AnnotationPositionCalculator;

import org.gvsig.annotation.calculator.AnnotationPositionCalculatorCreationException;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.task.AbstractMonitorableTask;

/**

 * Default {@link AnnotationCreationService} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultAnnotationCreationService extends AbstractMonitorableTask implements AnnotationCreationService {

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

	private static final String TEMPLATE_NAME = "template.gvslab";

	private static DataManager dataManager = DALLocator.getDataManager();

	private AnnotationManager manager;

	private FeatureStore sourceStore;

	private int sourceFontTypeAttribute = -1;

	private int sourceFontStyleAttribute = -1;

	private int sourceFontColorAttribute = -1;

	private int sourceRotationAttribute = -1;

	private int sourceHeigthAttribute = -1;

	private AnnotationPositionCalculator annotationPositionCalculator = null;

	private String destinationGeometryAttributeName = null;

	private AnnotationCreationFinishAction annotationCreationFinishAction = null; 

	/**

	 * {@link DefaultAnnotationCreationService} constructor with a

	 * {@link AnnotationManager}.

	 * 

	 * @param manager

	 *            to use in the service

	 * @throws DataException 

	 */

	public DefaultAnnotationCreationService(FeatureStore featureStore, AnnotationManager manager) throws DataException {

		super("annotation");

	    this.sourceStore = featureStore; 

		this.manager = manager;

		destinationGeometryAttributeName = featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

	}

	public AnnotationManager getManager() {

		return this.manager;

	}

	public FeatureStore createAnnotationStore(String destinationShapeFile, int textValueAttribute)

	throws AnnotationCreationException {		

		try {

			if (destinationShapeFile == null){

				throw new AnnotationCreationException("File can not be null");

			}	

			String destinationShapeFileWithoutExtension = destinationShapeFile.toLowerCase().replaceAll("\\.shp", "");

			if (destinationShapeFileWithoutExtension.length() == destinationShapeFile.length()-4){

				destinationShapeFileWithoutExtension =  destinationShapeFile.substring(0, destinationShapeFile.length()-4);

			}else{

				destinationShapeFileWithoutExtension = destinationShapeFile;

			}			

			NewFeatureStoreParameters newFeatureStoreParameters = (NewFeatureStoreParameters)dataManager.createNewStoreParameters("FilesystemExplorer", "Shape");

			newFeatureStoreParameters.setDynValue("shpfile", destinationShapeFileWithoutExtension + ".shp");

			newFeatureStoreParameters.setDynValue("dbffile", destinationShapeFileWithoutExtension + ".dbf");

			newFeatureStoreParameters.setDynValue("shxfile", destinationShapeFileWithoutExtension + ".shx");

			newFeatureStoreParameters.setDynValue("crs", sourceStore.getDefaultFeatureType().getDefaultSRS());

			EditableFeatureType editableFeatureType = sourceStore.getDefaultFeatureType().getEditable();//newFeatureStoreParameters.getDefaultFeatureType().getEditable();

			FeatureAttributeDescriptor[] featureAttributeDescriptors = editableFeatureType.getAttributeDescriptors();

			for (int i=featureAttributeDescriptors.length-1  ; i>=0 ; i--){

				editableFeatureType.remove(i);

			}

			initializeFeatureType(editableFeatureType);

			newFeatureStoreParameters.setDefaultFeatureType(editableFeatureType);

			dataManager.newStore("FilesystemExplorer", "Shape", newFeatureStoreParameters, true);

			//If there is not an annotationPositionCalculator it gets the default 

			if (annotationPositionCalculator == null){

				annotationPositionCalculator = manager.getDefaultAnnotationPositionCalculator();

			}	

			FeatureStore destinationStore = (FeatureStore) dataManager.openStore("Shape", newFeatureStoreParameters);

			copyFeatureStore(sourceStore, 

					destinationStore,

					textValueAttribute);	

			try {

				copyLegend(destinationStore);

			} catch (IOException e) {

				LOG.error("Error copying the legend");

			}

			if (annotationCreationFinishAction != null){

				annotationCreationFinishAction.finished(destinationStore);

			}

			return destinationStore;

		} catch (InitializeException e) {

			throw new AnnotationCreationException(e);

		} catch (ProviderNotRegisteredException e) {

			throw new AnnotationCreationException(e);

		} catch (ValidateDataParametersException e) {

			throw new AnnotationCreationException(e);

		} catch (DynFieldNotFoundException e) {

			throw new AnnotationCreationException(e);

		} catch (DataException e) {

			throw new AnnotationCreationException(e);

		} catch (AnnotationPositionCalculatorCreationException e) {

			throw new AnnotationCreationException(e);

		} 			

	}	

	public FeatureStore createAnnotationStore(String destinationShapeFile,

			String textValueAttributeName) throws AnnotationCreationException {

		try {

			return createAnnotationStore(destinationShapeFile, getIndex(textValueAttributeName));

		} catch (DataException e) {

			throw new AnnotationCreationException(e);

		}			

	}

	private void initializeFeatureType(EditableFeatureType editableFeatureType) throws DataException

	{		

		EditableFeatureAttributeDescriptor geometryType = editableFeatureType.add(destinationGeometryAttributeName, DataTypes.GEOMETRY);

		geometryType.setAllowNull(false);		

		geometryType.setGeometryType(Geometry.TYPES.POINT).setGeometrySubType(Geometry.SUBTYPES.GEOM2D);

		geometryType.setSRS(sourceStore.getDefaultFeatureType().getDefaultSRS());

		geometryType.setObjectClass(Geometry.class);

		editableFeatureType.setDefaultGeometryAttributeName(destinationGeometryAttributeName);

		editableFeatureType.add(AnnotationManager.TEXTVALUE_ATTRIBUTE_NAME, AnnotationDataTypes.TEXT, 256).setAllowNull(true);

		editableFeatureType.add(AnnotationManager.FONTTYPE_ATTRIBUTE_NAME, AnnotationDataTypes.FONTTYPE, 30).setAllowNull(true);

		editableFeatureType.add(AnnotationManager.FONTSTYLE_ATTRIBUTE_NAME, AnnotationDataTypes.FONTSTYLE, 30).setAllowNull(true);

		editableFeatureType.add(AnnotationManager.FONTCOLOR_ATTRIBUTE_NAME, AnnotationDataTypes.FONTCOLOR, 20).setAllowNull(true);

		editableFeatureType.add(AnnotationManager.FONTROTATION_ATTRIBUTE_NAME, AnnotationDataTypes.FONTROTATION, 5).setAllowNull(true);

		editableFeatureType.add(AnnotationManager.FONTHEGTH_ATTRIBUTE_NAME, AnnotationDataTypes.FONTHEIGHT, 5).setAllowNull(true);

	}

	private AttributeInserter createInserter(int attributePosition, Object defaultValue)

	{

		if (attributePosition > -1){

			return new StoreAttributeInserter(attributePosition);

		}else{

			return new DefaultAttributeInserter(defaultValue);

		}

	}

	private void copyFeatureStore(FeatureStore sourceStore,

			FeatureStore destinationStore, int textAttribute)

	throws AnnotationCreationException, DataException {		

		//Start the edition

		destinationStore.edit();

		//Copy data

		FeatureSet featureSet = sourceStore.getFeatureSet();

		DisposableIterator iterator = featureSet.iterator();

		taskStatus.setRangeOfValues(0, featureSet.getSize());

		//Create the attribute inserter's

		AttributeInserter fontTypeAttributeInserter = createInserter(sourceFontTypeAttribute, manager.getDefaultFontType());		

		AttributeInserter fontStyleAttributeInserter = createInserter(sourceFontStyleAttribute, manager.getDefaultFontStyle());		

		AttributeInserter fontColorAttributeInserter = createInserter(sourceFontColorAttribute, manager.getDefaultFontColor());		

		AttributeInserter fontRotationAttributeInserter = createInserter(sourceRotationAttribute, manager.getDefaultFontRotation());		

		AttributeInserter fontHeigthAttributeInserter = createInserter(sourceHeigthAttribute, manager.getDefaultFontHeight());		

		Feature sourceFeature;

		long featureCount = 0;

		while (iterator.hasNext()) {			

			sourceFeature = (Feature) iterator.next();

			EditableFeature destinationFeature = destinationStore.createNewFeature().getEditable();

			try {

				destinationFeature.set(destinationGeometryAttributeName, annotationPositionCalculator.getAnnotationPosition(sourceFeature));

			} catch (AnnotationPositionCalculationException e) {

				LOG.error("Not possible to get the point for the geometry", e);				

			}

			destinationFeature.set(AnnotationManager.TEXTVALUE_ATTRIBUTE_NAME, sourceFeature.get(textAttribute));

			destinationFeature.set(AnnotationManager.FONTTYPE_ATTRIBUTE_NAME, fontTypeAttributeInserter.getValue(sourceFeature));

			destinationFeature.set(AnnotationManager.FONTSTYLE_ATTRIBUTE_NAME, fontStyleAttributeInserter.getValue(sourceFeature));

			destinationFeature.set(AnnotationManager.FONTCOLOR_ATTRIBUTE_NAME, fontColorAttributeInserter.getValue(sourceFeature));

			destinationFeature.set(AnnotationManager.FONTROTATION_ATTRIBUTE_NAME, fontRotationAttributeInserter.getValue(sourceFeature));

			destinationFeature.set(AnnotationManager.FONTHEGTH_ATTRIBUTE_NAME, fontHeigthAttributeInserter.getValue(sourceFeature));

			destinationStore.insert(destinationFeature);

    		featureCount++;  

    		this.taskStatus.setCurValue(featureCount);

            if (this.taskStatus.isCancellationRequested()) {

                return;

            }

		}

		//Finish the edition

		destinationStore.finishEditing();

		//Dispose resources

		iterator.dispose();		

		featureSet.dispose();

		this.taskStatus.terminate();

        this.taskStatus.remove();		

	}

	private void copyLegend(FeatureStore destinationStore) throws ValidateDataParametersException, DataException, IOException {

		FilesystemServerExplorer filesystemServerExplorer = (FilesystemServerExplorer)destinationStore.getExplorer();

		File target = filesystemServerExplorer.getResourcePath(destinationStore, "gvslab");

		//Copy the template

		InputStream in = getClass().getClassLoader().getResourceAsStream(TEMPLATE_NAME);

		OutputStream out = null;

		out = new FileOutputStream(target);

		byte[] buf = new byte[1024];

		int len;

		while ((len = in.read(buf)) > 0) { 

			out.write(buf, 0, len); 

		} 

		in.close();

		out.close(); 		

	}

	private void checkAttribute(int index, int type) throws DataException{

		if (index >= sourceStore.getDefaultFeatureType().size()){

			throw new IllegalArgumentException("Attribute not found");

		}

		if (sourceStore.getDefaultFeatureType().getAttributeDescriptor(index).getDataType().getType() != type){

			throw new IllegalArgumentException("The Attribute has not have the fine type");

		}

	}

	public void setFontTypetAttribute(int index) throws DataException {

		checkAttribute(index, AnnotationDataTypes.FONTTYPE);

		this.sourceFontTypeAttribute = index;		

	}

	public void setFontStyleAttribute(int index) throws DataException {

		checkAttribute(index, AnnotationDataTypes.FONTSTYLE);

		this.sourceFontStyleAttribute = index;		

	}

	public void setFontColorAttribute(int index) throws DataException {

		checkAttribute(index, AnnotationDataTypes.FONTCOLOR);

		this.sourceFontColorAttribute = index;		

	}

	public void setFontHeigthAttribute(int index) throws DataException {

		checkAttribute(index, AnnotationDataTypes.FONTHEIGHT);

		this.sourceHeigthAttribute = index;		

	}

	public void setFontRotationAttribute(int index) throws DataException {

		checkAttribute(index, AnnotationDataTypes.FONTROTATION);

		this.sourceRotationAttribute = index;		

	}

	public void setAnnotationPositionCalculator(

			AnnotationPositionCalculator annotationPositionCalculator) {		

		this.annotationPositionCalculator = annotationPositionCalculator;		

	}

	public int getIndex(String attributeName) throws DataException{

		FeatureAttributeDescriptor featureAttributeDescriptor = sourceStore.getDefaultFeatureType().getAttributeDescriptor(attributeName);

		if (featureAttributeDescriptor != null){

			return featureAttributeDescriptor.getIndex();

		}

		return -1;

	}

	public void setFontColorAttribute(String attributeName) throws DataException {

		setFontColorAttribute(getIndex(attributeName));		

	}

	public void setFontHeigthAttribute(String attributeName) throws DataException {

		setFontHeigthAttribute(getIndex(attributeName));				

	}

	public void setFontRotationAttribute(String attributeName) throws DataException {

		setFontRotationAttribute(getIndex(attributeName));				

	}

	public void setFontStyleAttribute(String attributeName) throws DataException {

		setFontStyleAttribute(getIndex(attributeName));				

	}

	public void setFontTypetAttribute(String attributeName) throws DataException {

		setFontTypetAttribute(getIndex(attributeName));				

	}

	public FeatureStore getFeatureStore() {

		return sourceStore;

	}

	private interface AttributeInserter{

		public Object getValue(Feature feature);

	}

	private class StoreAttributeInserter implements AttributeInserter{

		private int attributePosition = -1;

		public StoreAttributeInserter(int attributePosition) {

			super();

			this.attributePosition = attributePosition;			

		}

		public Object getValue(Feature feature){

			return feature.get(attributePosition);

		}

	}

	private class DefaultAttributeInserter implements AttributeInserter{

		private Object defaultValue = null;

		public DefaultAttributeInserter(Object defaultValue) {

			super();	

			this.defaultValue = defaultValue;

		}

		public Object getValue(Feature feature){

			return defaultValue;

		}

	}

	public AnnotationCreationFinishAction getAnnotationCreationFinishAction() {

		return annotationCreationFinishAction;

	}

	public void setAnnotationCreationFinishAction(

			AnnotationCreationFinishAction annotationCreationFinishAction) {

		this.annotationCreationFinishAction = annotationCreationFinishAction;	

	}

}

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

import java.awt.Color;

import org.gvsig.annotation.AnnotationLibrary;

import org.gvsig.annotation.AnnotationLocator;

import org.gvsig.annotation.AnnotationManager;

import org.gvsig.annotation.impl.calculator.CentroidPositionCalculatior;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

/**

 * Library for default implementation initialization and configuration.

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class AnnotationDefaultImplLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(AnnotationLibrary.class);

    }

	@Override

    protected void doInitialize() throws LibraryException {

		AnnotationLocator.registerManager(DefaultAnnotationManager.class);           

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        AnnotationManager annotationManager = AnnotationLocator.getManager();

        if (annotationManager == null) {

            throw new ReferenceNotRegisteredException(

                AnnotationLocator.MANAGER_NAME, AnnotationLocator

                    .getInstance());

        }

        annotationManager.registerDefaultAnnotationPositionCalculator(CentroidPositionCalculatior.class);

        //Adding font types

        annotationManager.addFontType("Arial");

        annotationManager.addFontType("Dialog");

        annotationManager.addFontType("DialogInput");

        annotationManager.addFontType("Serif");

        annotationManager.addFontType("SansSerif");

        annotationManager.addFontType("Monospaced");

        annotationManager.addFontType("Courier");

        annotationManager.addFontType("TimesRoman");

        annotationManager.addFontType("Helvetica");

           //Adding font styles

        annotationManager.addFontStyle("Plain");

        annotationManager.addFontStyle("Italic");

        annotationManager.addFontStyle("Bold");

        //Setting the default values if there are not registered

        if (annotationManager.getDefaultTextValue() == null){

        	annotationManager.setDefaultTextValue("Text");

        }

        if (annotationManager.getDefaultFontColor() == -1){

        	annotationManager.setDefaultFontColor(Color.BLACK);

        }

        if (annotationManager.getDefaultFontHeight() == -1){

        	annotationManager.setDefaultFontHeight(10);

        }

        if (annotationManager.getDefaultFontRotation() == -1){

        	annotationManager.setDefaultFontRotation(0);

        }

        if (annotationManager.getDefaultFontStyle() == null){

        	annotationManager.setDefaultFontStyle("Plain");

        }

        if (annotationManager.getDefaultFontType() == null){

        	annotationManager.setDefaultFontType("Arial");

        }        

    }

}

/* 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):

* 2010 {Prodevelop}   {Task}

*/

package org.gvsig.annotation.impl.calculator;

import org.gvsig.annotation.calculator.AnnotationPositionCalculationException;

import org.gvsig.annotation.calculator.AnnotationPositionCalculator;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

import org.gvsig.i18n.Messages;

/**

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

 */

public class CentroidPositionCalculatior implements AnnotationPositionCalculator{

	public Point getAnnotationPosition(Feature feature) throws AnnotationPositionCalculationException {

		try {

			return feature.getDefaultGeometry().centroid();

		} catch (GeometryOperationNotSupportedException e) {

			throw new AnnotationPositionCalculationException(e);

		} catch (GeometryOperationException e) {

			throw new AnnotationPositionCalculationException(e);

		}

	}

	public String getName() {

		return Messages.getText("centroid");

	}

}

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

import java.awt.Color;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.gvsig.annotation.AnnotationCreationService;

import org.gvsig.annotation.AnnotationCreationServiceException;

import org.gvsig.annotation.AnnotationManager;

import org.gvsig.annotation.calculator.AnnotationPositionCalculator;

import org.gvsig.annotation.calculator.AnnotationPositionCalculatorCreationException;

import org.gvsig.fmap.dal.exception.DataException;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.service.ServiceException;

/**

 * Default {@link AnnotationManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultAnnotationManager implements AnnotationManager {

	private static final String ANNOTATION_POSITION_CALCULATOR_EXTENSION_POINT = "AnnotationPositionCalculatorExtensionPoint";

	private ExtensionPointManager extensionPointManager = ToolsLocator.getExtensionPointManager();

	private static final String DEFAULT_ANNOTATION_POSITION_CALCULATOR = "DefaultAnnotationPositionCalculator";

	private String defaultTextValue = null;

	private int defaultFontColor = -1;

	private double defaultFontHeight = -1;

	private double defaultFontRotation = -1;

	private String defaultFontStyle = null;

	private String defaultFontType = null;

	private List<String> fontTypes = Collections.synchronizedList(new ArrayList<String>());

	private List<String> fontStyles = Collections.synchronizedList(new ArrayList<String>());

    public AnnotationCreationService getAnnotationCreationService(FeatureStore featureStore)

        throws ServiceException {

        AnnotationCreationService fc;

		try {

			fc = new DefaultAnnotationCreationService(featureStore, this);

		} catch (DataException e) {

			throw new AnnotationCreationServiceException("Impossible to create the annotation service", e);

		}

        return fc;

    }

	public AnnotationPositionCalculator getAnnotationPositionCalculator(

			String name) throws AnnotationPositionCalculatorCreationException {

		if (extensionPointManager.get(ANNOTATION_POSITION_CALCULATOR_EXTENSION_POINT).has(name)){

			try {

				return (AnnotationPositionCalculator)extensionPointManager.get(ANNOTATION_POSITION_CALCULATOR_EXTENSION_POINT).create(name);

			} catch (InstantiationException e) {

				throw new AnnotationPositionCalculatorCreationException(name, e);

			} catch (IllegalAccessException e) {

				throw new AnnotationPositionCalculatorCreationException(name, e);

			}

		}else{

			throw new IllegalArgumentException("There is not an annotation position calculator registered with this name"); 

		}		

	}

	public List<String> getAnnotationPositionCalculatorList() {

		return extensionPointManager.get(ANNOTATION_POSITION_CALCULATOR_EXTENSION_POINT).getNames();

	}

	public AnnotationPositionCalculator getDefaultAnnotationPositionCalculator() throws AnnotationPositionCalculatorCreationException {

		return getAnnotationPositionCalculator(DEFAULT_ANNOTATION_POSITION_CALCULATOR);

	}

	public void registerAnnotationPositionCalculator(String name,

			Class annotationPositionCalculatorClass) {

		if (!AnnotationPositionCalculator.class.isAssignableFrom(annotationPositionCalculatorClass)) {

			throw new IllegalArgumentException(annotationPositionCalculatorClass.getName()

					+ " must implement the AnnotationPositionCalculator interface");

		}

		ExtensionPoint extensionPoint = extensionPointManager.add(ANNOTATION_POSITION_CALCULATOR_EXTENSION_POINT, "");

		extensionPoint.append(name, name, annotationPositionCalculatorClass);		

	}

	public void registerDefaultAnnotationPositionCalculator(Class annotationPositionCalculatorClass) {

		registerAnnotationPositionCalculator(DEFAULT_ANNOTATION_POSITION_CALCULATOR,

				annotationPositionCalculatorClass);

	}

	public void addFontStyle(String fontStyle) {

		fontStyles.add(fontStyle);		

	}

	public void addFontType(String fontType) {

		fontTypes.add(fontType);		

	}

	public int getDefaultFontColor() {

		return defaultFontColor;

	}

	public double getDefaultFontHeight() {

		return defaultFontHeight;

	}

	public double getDefaultFontRotation() {

		return defaultFontRotation;

	}

	public String getDefaultFontStyle() {

		return defaultFontStyle;

	}

	public String getDefaultFontType() {

		return defaultFontType;

	}

	public String getDefaultTextValue() {

		return defaultTextValue;

	}

	public List<String> getFontStyles() {

		return fontStyles;

	}

	public List<String> getFontTypes() {

		return fontTypes;

	}

	public void setDefaultFontColor(int fontColor) {

		this.defaultFontColor = fontColor;		

	}

	public void setDefaultFontColor(Color fontColor) {

		this.defaultFontColor = fontColor.getRGB();		

	}

	public void setDefaultFontHeight(double fontHeight) {

		this.defaultFontHeight = fontHeight;		

	}

	public void setDefaultFontRotation(double fontRotation) {

		this.defaultFontRotation = fontRotation;		

	}

	public void setDefaultFontStyle(String fontStyle) {

		this.defaultFontStyle = fontStyle;		

	}

	public void setDefaultFontType(String fontType) {

		this.defaultFontType = fontType;		

	}

	public void setDefaultTextValue(String textValue) {

		this.defaultTextValue = textValue;		

	}

}

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

</head>

<body>

	<p>Annotation library API default implementation.</p>

</body>

</html>

# Resource bundle texts for the Spanish language locale (es)

centroid=Centroide

# Resource bundle texts for the English language locale (en)

centroid=Centroid

org.gvsig.annotation.impl.AnnotationDefaultImplLibrary

<?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.annotation.lib.impl</artifactId>

	<packaging>jar</packaging>

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

	<parent>

		<groupId>org.gvsig</groupId>

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

		<version>1.0.0-SNAPSHOT</version>

	</parent>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<version>1.0.0-SNAPSHOT</version>

            <scope>compile</scope>

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.i18n</artifactId>		

            <scope>compile</scope>

		</dependency>

			<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.projection</artifactId>

            <scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

		</dependency>				

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>operation</classifier>		

            <scope>compile</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.metadata.lib.basic.api</artifactId>            

            <scope>compile</scope>

        </dependency>  

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>             

		<dependency>

			<groupId>org.opengis</groupId>

		    <artifactId>geoapi</artifactId>

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>org.geotools</groupId>

			<artifactId>gt2-main</artifactId>

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>javax.media</groupId>

			<artifactId>jai_core</artifactId>

			<scope>runtime</scope>

		</dependency>

		<dependency>

			<groupId>javax.media</groupId>

			<artifactId>jai_codec</artifactId>

			<scope>runtime</scope>

		</dependency>		

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<version>1.0.0-SNAPSHOT</version>

			<type>test-jar</type>

			<scope>test</scope>

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>spi</classifier>

			<scope>runtime</scope>		

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>impl</classifier>

			<scope>runtime</scope>

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>store.shp</classifier>

			<scope>test</scope>	

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>store.dbf</classifier>

			<scope>test</scope>	

		</dependency>

		<dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection</artifactId>  

            <classifier>cresques-impl</classifier>

            <scope>runtime</scope>		

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

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

			<classifier>impl</classifier>

			<scope>runtime</scope>		

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.compat</artifactId>			

			<scope>runtime</scope>		

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.compat</artifactId>			

			<classifier>se</classifier>		

			<scope>runtime</scope>		

		</dependency>	

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal.index.spatial</artifactId>

			<classifier>jts</classifier>

			<scope>runtime</scope>

		</dependency>		

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>           

            <scope>compile</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/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

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

	<packaging>pom</packaging>

	<name>org.gvsig.annotation.lib</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.annotation</artifactId>

		<version>1.0.0-SNAPSHOT</version>

	</parent>

	<modules>

		<module>org.gvsig.annotation.lib.api</module>

		<module>org.gvsig.annotation.lib.impl</module>

	</modules>

</project>

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

/**

 * Exception thrown when there is an error creating an Annotation layer.

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class AnnotationCreationException extends AnnotationException {

    private static final long serialVersionUID = -4051458353306878010L;

    private static final String MESSAGE =

        "An error has been produced " + "creating the Annotation layer";

    private static final String KEY = "_AnnotationCreationException";

    /**

     * Creates a new {@link AnnotationCreationException}.

     * 

     * @param cause

     *            the original cause

     */

    public AnnotationCreationException(Throwable cause) {

        super(MESSAGE, cause, KEY, serialVersionUID);

    }

    public AnnotationCreationException(String message) {

        super(message, KEY, serialVersionUID);

    }

}

/* 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):

* 2010 {Prodevelop}   {Task}

*/

package org.gvsig.annotation;

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

/**

 * Action that can be executed at the end of the annotation 

 * creation process. An example of action can be load the destination

 * {@link FeatureStore} like a layer in a view.

 * 

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

 */

public interface AnnotationCreationFinishAction {

	/**

	 * This method is called at the end of an annotation

	 * creation process.

	 * @param featureStore

	 * the destination store.

	 */

	public void finished(FeatureStore featureStore);

}

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

import org.gvsig.tools.locator.BaseLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

/**

 * This locator is the entry point for the Annotation library, providing

 * access to all Annotation services through the {@link AnnotationManager}

 * .

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class AnnotationLocator extends BaseLocator {

    /**

     * Annotation manager name.

     */

    public static final String MANAGER_NAME = "Annotation.manager";

    /**

     * Annotation manager description.

     */

    public static final String MANAGER_DESCRIPTION = "Annotation Manager";

    private static final String LOCATOR_NAME = "Annotation.locator";

    /**

     * Unique instance.

     */

    private static final AnnotationLocator INSTANCE =

        new AnnotationLocator();

    /**

     * Return the singleton instance.

     * 

     * @return the singleton instance

     */

    public static AnnotationLocator getInstance() {

        return INSTANCE;

    }

    /**

     * Return the Locator's name.

     * 

     * @return a String with the Locator's name

     */

    public final String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Return a reference to the AnnotationManager.

     * 

     * @return a reference to the AnnotationManager

     * @throws LocatorException

     *             if there is no access to the class or the class cannot be

     *             instantiated

     * @see Locator#get(String)

     */

    public static AnnotationManager getManager() throws LocatorException {

        return (AnnotationManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * Registers the Class implementing the AnnotationManager interface.

     * 

     * @param clazz

     *            implementing the AnnotationManager interface

     */

    public static void registerManager(

        Class<? extends AnnotationManager> clazz) {

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

}

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

</head>

<body>

	<p>Annotation library API.</p>

	<p>

	It allows to get new Annotation and get their text.

	</p>

</body>

</html>

/* 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):

* 2010 {Prodevelop}   {Task}

*/

package org.gvsig.annotation;

import org.gvsig.tools.service.ServiceException;

/**

 * Exception thrown by the {@link AnnotationCreationService}.

 * 

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

 */

public class AnnotationCreationServiceException extends ServiceException {

	private static final long serialVersionUID = -4200816057552322619L;

	private final static String MESSAGE_KEY = "_AnnotationCreationServiceException";	

	public AnnotationCreationServiceException(String message, Throwable e) {