Application: gvSIG desktop

<project name="Generar extension en Andami" default="generate-without-source" basedir=".">

    <description>

        Instala el plugin de ejemplo en Andami.

    </description>

  <!-- set global properties for this build -->

  <property name="src" location="src"/>

  <property name="build" location="bin"/>

  <property name="dist"  location="dist"/>

  <property name="plugin" value="es.prodevelop.gvsig.exportMobile"/>

  <property name="extension-dir" location="C:/Archivos de programa/gvSIG_1.1final/bin/gvSIG/extensiones"/>

  <property name="install-tree-dir" location="C:/Archivos de programa/gvSIG_1.1final/bin/gvSIG/extensiones"/>

  <target name="init">

    <!-- Create the time stamp -->

    <tstamp/>

    <!-- Create the build directory structure used by compile -->

    <mkdir dir="${build}"/>

    <mkdir dir="${dist}"/>

  	<!-- Creamos un fichero con el timeStamp para que lo lea el FPanelAbout -->

  	<buildnumber/> 

  </target>

  <target name="generate-without-source" description="generate the distribution without the source file" >

    <!-- Create the distribution directory -->

    <mkdir dir="${dist}"/>

    <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->

    <jar jarfile="${dist}/${plugin}.jar" basedir="${build}"/>

    <copy file="config/config.xml" todir="${dist}"/>

    <copy todir="${dist}">

    	<fileset dir="." includes="text*.properties"/>

    </copy>

    <copy todir="${dist}/images">

    	<fileset dir="images/" includes="*"/>

    </copy>

    <move todir="${extension-dir}/${plugin}/">

    	<fileset dir="${dist}" includes="**/**"/>

    </move>

  </target>

	  <target name="generate-install-tree-export-only" description="generate the install tree" >

	    <!-- Create the distribution directory -->

	    <mkdir dir="${dist}"/>

	    <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->

	    <jar jarfile="${dist}/${plugin}.jar" basedir="${build}"/>

	    <copy file="config/config.xml" todir="${dist}"/>

	    <copy todir="${dist}">

	    	<fileset dir="." includes="text*.properties"/>

	    </copy>

	    <copy todir="${dist}/images">

	    	<fileset dir="images/" includes="*"/>

	    </copy>

	    <move todir="./install/bin/gvSIG/extensiones/${plugin}/">

	    	<fileset dir="${dist}" includes="**/**"/>

	    </move>

	  </target>

	<!--

	<target name="clean-install-tree-export-synchro">

		<delete>

			<fileset dir="./install/pub/">

			    <include name="*.zip"/>

			</fileset>

			<fileset dir="./install/export_installer/">

			    <include name="*.jar"/>

			</fileset>

		</delete>

		<delete dir="./install/bin" />

		<mkdir dir="./install/bin" />

		<mkdir dir="./install/bin/gvSIG" />

		<mkdir dir="./install/bin/gvSIG/extensiones" />

	</target>

	-->

</project>

package es.prodevelop.gvsig.exportMobile.files;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import org.apache.log4j.Logger;

/**

 * Manages the directory when a gvsig mobile project 

 * with his data will be stored

 * 

 * @author Anabel Moreno

 *

 */

public class NewDir {

	private static Logger logger = Logger.getLogger(NewDir.class.getName());

	private String namePath;

	private File newFileProy;

	private File[] filesDir;

	private int numFiles;

	public static final String tempDirectoryPath = System.getProperty("java.io.tmpdir")+"/tmp-andami";

	/**

	 * Create new output file

	 * 

	 * @param dirOutPut

	 */

	public NewDir(String dirOutPut) {

		namePath = (dirOutPut + File.separator);

		newFileProy = new File(namePath);

	}

	/** 

	 * @return true if the directory is empty

	 */

	public boolean isEmpty() {

		filesDir = newFileProy.listFiles();

		numFiles = filesDir.length;

		if (contFiles(filesDir) == 0)

			return true;

		else

			return false;

	}

	/**

	 * Count the name of files in a directory

	 * 

	 * @param arrFiles

	 * @return the number of files in a directory

	 */

	private int contFiles(File[] arrFiles) {

		int cont = 0;

		for (int i = 0; i < arrFiles.length; i++) {

			if (arrFiles[i].exists()) {

				cont++;

			}

		}

		return cont;

	}

	/**

	 * Delete files

	 */

	public void deleteFiles() {

		for (int i = 0; i < numFiles; i++) {

			filesDir[i].delete();

		}

	}

	/**

	 * if file exists and is directory, while this file is full, the files that

	 * are into the file will be deleted

	 * 

	 * @return output directory

	 */

	public File ifExistDir() {

		File outputPath = null;

		if (newFileProy.exists()) {

			if (newFileProy.isDirectory()) {

				// to delete, the directory has to be empty

				while (isEmpty() == false) {

					deleteFiles();

				}

				File deletedFile = newFileProy;

				boolean delete = deletedFile.delete();

				// if (delete) System.out.println("delete file");

				// else System.out.println("not delete");

			}

		}

		/** new directory */

		boolean mk = newFileProy.mkdir();

		if (mk == true) {

			/* create output File for result layer */

			outputPath = new File(newFileProy.getAbsolutePath());

		}

		return outputPath;

	}

	public static void copyFile(File in, File out) {

		FileInputStream fis = null;

		FileOutputStream fos = null;

		try {

		    fis  = new FileInputStream(in);

		    fos = new FileOutputStream(out);

	        byte[] buf = new byte[1024];

	        int i = 0;

	        while ((i = fis.read(buf)) != -1) {

	            fos.write(buf, 0, i);

	        }

	        if (fis != null) fis.close();

	        if (fos != null) fos.close();

	    } catch (Exception e) {

	        logger.error("Unable to copy file: " + e.getMessage());

	    }

	}

	public static void copyShpDbfShxTempToFinal(File source, File dest) {

		if (dest == null) {

			logger.error("Unable to copy temp to file: finalFile is NULL !");

		}

		if (source == null) {

			logger.error("Unable to copy temp to file: tempFile is NULL !");

		}

		int temp_last_shp = source.getAbsolutePath().toLowerCase().lastIndexOf(".shp");

		String temp_base = source.getAbsolutePath().substring(0, temp_last_shp);

		int final_last_shp = dest.getAbsolutePath().toLowerCase().lastIndexOf(".shp");

		String final_base = dest.getAbsolutePath().substring(0, final_last_shp);

		NewDir.copyFile(source, dest);

		File f_in = new File(temp_base + ".dbf"); 

		File f_out = new File(final_base + ".dbf");

		NewDir.copyFile(f_in, f_out);

		f_in = new File(temp_base + ".shx"); 

		f_out = new File(final_base + ".shx");

		NewDir.copyFile(f_in, f_out);

	}

	public static File getTempShpFile() {

		File f = null;

		String t = "" + System.currentTimeMillis();

		try {

			f = File.createTempFile(t, ".shp");

			f.deleteOnExit();

		} catch (IOException e) {

			logger.error("Unable to create temp file: " + e.getMessage());

		}

		return f;

	}

}

package es.prodevelop.gvsig.exportMobile;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrRaster;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.FLyrWMS;

/**

 * Create a layer object with its checkbox, button, combo and description change

 * the name to the layer if the name layer is duplicate

 * 

 * @author Anabel Moreno

 * 

 */

public class LayerObject {

	private JCheckBox boxLyr;

	private String nameLyr;

	private JComboBox comboLyr;

	private FieldDescription[] description;

	private FLayer lyr;

	private JButton buttonLyr;

	private JPanel parent;

	private JLabel isInto;

	// private String nameNew;

	/**

	 * @param box

	 *            layer

	 * @param name

	 *            layer order

	 * @param combo

	 *            layer

	 * @param layer

	 * @param button

	 *            layer

	 */

	public LayerObject(JCheckBox box, String name, JComboBox combo,

			FLayer layerwn, JButton button,JPanel pa) {

		parent=pa;

		boxLyr = box;

		nameLyr = name;

		comboLyr = combo;

		buttonLyr = button;

		try {

			// lyr = layer.cloneLayer();

			// lyr.setName(nameLyr);

			// lyr.setProjection(layer.getProjection());

			// jldominguez december 2007

			lyr = layerwn;

		} catch (Exception e) {

			e.printStackTrace();

		}

		if(boxLyr.isSelected()==true){

			if(lyr instanceof FLyrVect){

				comboLyr.setEnabled(true);

				buttonLyr.setEnabled(true);

			}

			if(lyr instanceof FLyrRaster){

				comboLyr.setEnabled(true);

				buttonLyr.setEnabled(false);

			}

		}

		else{

				comboLyr.setEnabled(false);

				buttonLyr.setEnabled(false);

		}

		if (lyr instanceof FLyrRaster) {

			buttonLyr.setEnabled(false);

		}

		if (lyr instanceof FLyrWMS) {

			comboLyr.setEnabled(false);

			buttonLyr.setEnabled(false);

		}

	}

	/**

	 * @return parent

	 */

	public JPanel getParent(){

		return parent;

	}

	/**

	 * Set box layer selected

	 * 

	 * @param st

	 */

	public void setBoxStatus(boolean st) {

		boxLyr.setSelected(st);

	}

	/**

	 * @return layer button

	 */

	public JButton getButton() {

		return buttonLyr;

	}

	/**

	 * @return layer name

	 */

	public String getName() {

		return nameLyr;

	}

	/**

	 * Change layer name

	 * @param name

	 */

	public void setName(String n){

		nameLyr = n;

	}

	/**

	 * @return layer checkbox

	 */

	public JCheckBox getBox() {

		return boxLyr;

	}

	/**

	 * @return layer combo

	 */

	public JComboBox getCombo() {

		return comboLyr;

	}

	/**

	 * set combo properties (enabled and selected index)

	 * @param combo

	 * @param indx

	 */

	public void setCombo(boolean combo,int indx){

		comboLyr.setEnabled(combo);

		comboLyr.setSelectedIndex(indx);

	}

	/**

	 * Set layer field description

	 * 

	 * @param atribSelected

	 */

	public void setDescription(FieldDescription[] atribSelected) {

		description = atribSelected;

	}

	/**

	 * @return layer description

	 */

	public FieldDescription[] getDescription() {

		return description;

	}

	/**

	 * set image layer, if this is into the view, and create a label with this image

	 * @param imgInto

	 */

	public void setImage(JLabel imgInto){

		isInto=imgInto;

	}

	/**

	 * @return image label

	 */

	public JLabel getImgLbl(){

		return isInto;

	}

	public FLayer getLyr() {

		return lyr;

	}

	public void setLyr(FLayer lyr) {

		this.lyr = lyr;

	}

}

package es.prodevelop.gvsig.exportMobile;

import java.util.ArrayList;

import com.iver.andami.PluginServices;

import com.iver.andami.plugins.Extension;

import com.iver.cit.gvsig.About;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.project.ProjectExtent;

import com.iver.cit.gvsig.project.documents.view.gui.View;

import es.prodevelop.gvsig.exportMobile.ui.order.FLayerWithNewName;

import es.prodevelop.gvsig.exportMobile.ui.panels.ExportPanel;

/**

 * 

 * This extension allows a user to export all the layers in a view

 * 

 * @author amoreno

 *

 */

public class ClipExtension extends Extension {

	/**

	 * Starts the extension

	 */

	public void initialize() {

        // about

        java.net.URL newurl =

        	createResourceUrl("about/export-mobile-about.html");

        About claseAbout = (About) PluginServices.getExtension(com.iver.cit.gvsig.About.class);

        claseAbout.getAboutPanel().addAboutUrl("Export to gvSIG Mobile", newurl);

	}

	public boolean isEnabled() {

		return true;

	}

	/**

	 * is visible when a view is the active window

	 */

	public boolean isVisible() {

		com.iver.andami.ui.mdiManager.IWindow f = (com.iver.andami.ui.mdiManager.IWindow) PluginServices

				.getMDIManager().getActiveWindow();

		if (f == null) {

			return false;

		}

		return (f instanceof View);

	}

	/**

	 * @param actionCommand not used

	 * It's called when the export to gvsig mobile button is pressed

	 */

	public void execute(String actionCommand) {

		View view = (View) PluginServices.getMDIManager().getActiveWindow();

		view.getModel().getProject().getExtents();

		// root

		FLayers rt = view.getMapControl().getMapContext().getLayers();

		ArrayList lyrsNewName = FLayerWithNewName.getAll(rt);

		ProjectExtent[] listExtent = view.getModel().getProject().getExtents();

		ExportPanel infPanel = new ExportPanel(lyrsNewName, listExtent);

		PluginServices.getMDIManager().addWindow(infPanel);

	}

    private java.net.URL createResourceUrl(String path) {

        return getClass().getClassLoader().getResource(path);

    }

}

package es.prodevelop.gvsig.exportMobile.rectangle;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.cresques.cts.IProjection;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.MapControl;

import com.iver.cit.gvsig.fmap.core.FPolygon2D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.GeneralPathX;

import com.iver.cit.gvsig.fmap.drivers.ConcreteMemoryDriver;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayerVectorialDB;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.LayerFactory;

import com.iver.cit.gvsig.project.documents.view.gui.View;

/**

 * Utility to create layers with rectangles

 * 

 * @author Anabel Moreno

 * 

 */

public class DrawRectangle {

	private Rectangle2D rect;

	private FShape shp;

	private View v;

	private static String RECTANGLE = "Rectangle";

	public DrawRectangle(View view) {

		v = view;

	}

	public Rectangle2D getRectangle() {

		return rect;

	}

	/**

	 * Set the rectangle of the view

	 */

	public void setRectView() {

		rect = v.getMapControl().getViewPort().getAdjustedExtent();

	}

	/**

	 * Set rectangle of the extent

	 * @param recExtent

	 */

	public void setRectExtent(Rectangle2D recExtent) {

		rect = recExtent;

	}

	/**

	 * Create and draw a new rectangle poligon

	 * 

	 * @param mapCtrl

	 * @return layer

	 */

	public FLayer draw(MapControl mapCtrl) {

		/* DRIVER DEFINITION (SHAPE TYPE AND FIELDS) */

		ConcreteMemoryDriver driver = new ConcreteMemoryDriver();

		driver.setShapeType(FShape.POLYGON);

		ArrayList arrayFields = new ArrayList();

		arrayFields.add("ID");

		Value[] auxRow = new Value[1];

		driver.getTableModel().setColumnIdentifiers(arrayFields.toArray());

		/* GEOMETRY DEFINITION */

		GeneralPathX rectangulo = new GeneralPathX();

		// rect is the rectangle extent of the view

		/* NEW RECTANGLE */

		rectangulo.moveTo(rect.getMinX(), rect.getMinY());

		rectangulo.lineTo(rect.getMinX(), rect.getMaxY());

		rectangulo.lineTo(rect.getMaxX(), rect.getMaxY());

		rectangulo.lineTo(rect.getMaxX(), rect.getMinY());

		rectangulo.closePath();

		shp = new FPolygon2D(rectangulo);

		/* ATRIBUTES */

		auxRow[0] = ValueFactory.createValue(0);

		/* ADD RECORD */

		driver.addShape(shp, auxRow);

		/* CREATE AND ADD LAYER */

		FLayer lyr;

		String layerName = RECTANGLE;

		lyr = LayerFactory.createLayer(layerName, driver, mapCtrl

				.getProjection());

		return lyr;

	}

	/**

	 * Create and draw a new rectangle poligon

	 * 

	 * @param rect

	 * @return layer

	 */

	public static FLyrVect createRectangleLayer(Rectangle2D rect, IProjection projection) {

		/* DRIVER DEFINITION (SHAPE TYPE AND FIELDS) */

		ConcreteMemoryDriver driver = new ConcreteMemoryDriver();

		driver.setShapeType(FShape.POLYGON);

		ArrayList arrayFields = new ArrayList();

		arrayFields.add("ID");

		Value[] auxRow = new Value[1];

		driver.getTableModel().setColumnIdentifiers(arrayFields.toArray());

		/* GEOMETRY DEFINITION */

		GeneralPathX rectangulo = new GeneralPathX();

		// rect is the rectangle extent of the view

		/* NEW RECTANGLE */

		rectangulo.moveTo(rect.getMinX(), rect.getMinY());

		rectangulo.lineTo(rect.getMinX(), rect.getMaxY());

		rectangulo.lineTo(rect.getMaxX(), rect.getMaxY());

		rectangulo.lineTo(rect.getMaxX(), rect.getMinY());

		rectangulo.closePath();

		FPolygon2D shp = new FPolygon2D(rectangulo);

		/* ATRIBUTES */

		auxRow[0] = ValueFactory.createValue(0);

		/* ADD RECORD */

		driver.addShape(shp, auxRow);

		/* CREATE AND ADD LAYER */

		FLyrVect lyr;

		String layerName = RECTANGLE;

		lyr = (FLyrVect)LayerFactory.createLayer(layerName, driver, projection);

		return lyr;

	}

}

package es.prodevelop.gvsig.exportMobile;

import java.net.URL;

import javax.swing.ImageIcon;

import org.apache.log4j.Logger;

/**

 * Class to access the icons used by the extension

 * @author amoreno

 *

 */

public class CreateImage {

	private Logger logger = Logger.getLogger(CreateImage.class.getClass());

	public CreateImage() {

	}

	/**

	 * Get path image

	 * 

	 * @param path

	 * @return URL

	 */

	public java.net.URL createResourceUrl(String path) {

		return getClass().getClassLoader().getResource(path);

	}

	/**

	 * Create image icon

	 * 

	 * @param path

	 *            where the image is into.

	 * @param description

	 *            of the image.

	 * @return ImageIcon

	 */

	public ImageIcon createImageIcon(URL path, String description) {

		java.net.URL imgURL = path;

		if (imgURL != null) {

			return new ImageIcon(imgURL, description);

		} else {

			logger.error("Couldn't find file: " + path);

			return null;

		}

	}

}

package es.prodevelop.gvsig.exportMobile.layerexporters.clip;

import java.awt.geom.Rectangle2D;

import java.util.Map;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.ILayerDefinition;

import com.iver.cit.gvsig.fmap.edition.ISchemaManager;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLayerVectorialDB;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.operations.strategies.Strategy;

import com.iver.cit.gvsig.fmap.operations.strategies.StrategyManager;

import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;

import com.iver.cit.gvsig.geoprocess.core.fmap.AbstractGeoprocess;

import com.iver.cit.gvsig.geoprocess.core.fmap.GeoprocessException;

import com.iver.cit.gvsig.geoprocess.core.fmap.IOverlayGeoprocess;

import com.iver.cit.gvsig.geoprocess.core.fmap.XTypes;

import com.iver.cit.gvsig.geoprocess.impl.clip.fmap.ClipVisitor;

import com.iver.cit.gvsig.geoprocess.impl.convexhull.fmap.ScalableUnionVisitor;

import com.iver.utiles.swing.threads.CancellableMonitorable;

import com.iver.utiles.swing.threads.DefaultCancellableMonitorable;

import com.iver.utiles.swing.threads.IMonitorableTask;

import com.vividsolutions.jts.geom.Geometry;

//ClipProcess is as ClipGeoprocess but createLayerDefinition method

//is diferent because we have to add some original layer`s atributes (new description)

//to export not all layer`s atributes

public class ClipProcess extends AbstractGeoprocess implements

		IOverlayGeoprocess {

	private FLyrVect auxLayer;

	private boolean onlyFirstLayerSelection = false;

	private boolean onlyClipLayerSelection = false;

	private ClipVisitor visitor;

	private ILayerDefinition resultLayerDefinition;

	private FieldDescription[] description;

	//private FLayerWithNewName firstWN;

	private FLyrVect firstWN;

	private FBitSet bitset;

	public ClipProcess(FLyrVect lyr_wn, FieldDescription[] desc) {

		firstWN = lyr_wn;

		setFirstOperand(lyr_wn);

		description = desc;

	}

	public ClipProcess(FLyrVect lyr_wn, FieldDescription[] desc, FBitSet bitset) {

		firstWN = lyr_wn;

		setFirstOperand(lyr_wn);

		description = desc;

		this.bitset=bitset;

	}

	/** set parameters */

	public void setParameters(Map params) throws GeoprocessException {

		Boolean firstLayerSelection = (Boolean) params

				.get("firstlayerselection");

		if (firstLayerSelection != null)

			this.onlyFirstLayerSelection = firstLayerSelection.booleanValue();

		Boolean secondLayerSelection = (Boolean) params

				.get("secondlayerselection");

		if (secondLayerSelection != null)

			this.onlyClipLayerSelection = secondLayerSelection.booleanValue();

	}

	public void checkPreconditions() throws GeoprocessException {

		// TODO Auto-generated method stub

		if (firstLayer == null)

			throw new GeoprocessException("Clip: capa de entrada a null");

		if (auxLayer == null)

			throw new GeoprocessException("Clip: capa de clip a null");

		if (this.writer == null || this.schemaManager == null) {

			throw new GeoprocessException(

					"Operacion de clip sin especificar capa de resultados");

		}

		try {

			if (auxLayer.getShapeType() != XTypes.POLYGON

					&& (auxLayer.getShapeType() != XTypes.MULTI)) {

				throw new GeoprocessException(

						"La capa de recorte no es de pol?gonos");

			}

		} catch (com.iver.cit.gvsig.fmap.DriverException e) {

			throw new GeoprocessException(

					"Error al tratar de chequear si la capa de recorte es de pol?gonos");

		}

	}

	public void process() throws GeoprocessException {

		// TODO Auto-generated method stub

		Geometry clippingGeometry = null;

		try {

			clippingGeometry = computeJtsClippingPoly();

		} catch (Exception e) {

			throw new GeoprocessException(

					"Error calculando el convex hull de la clipping layer");

		}

		visitor = new ClipVisitor(clippingGeometry, resultLayerDefinition,

				schemaManager, writer);

		Strategy strategy = StrategyManager.getStrategy(firstLayer);

		try {

			if (onlyFirstLayerSelection) {

				strategy.process(visitor, firstLayer.getRecordset()

						.getSelection());

			} else {

				strategy.process(visitor);

			}

		} catch (Exception e) {

			throw new GeoprocessException(

					"Problemas al leer los datos de la capa a clipear");

		}

	}

	public ILayerDefinition createLayerDefinition() {

		/*LayerDescription descripLayer = new LayerDescription(

				resultLayerDefinition, firstWN, description);

		resultLayerDefinition = descripLayer.lyrDescrip();*/

		return resultLayerDefinition;

	}

	public void setSecondOperand(FLyrVect secondLayer) {

		// TODO Auto-generated method stub

		this.auxLayer = secondLayer;

	}

	public void setFirstOperand(FLyrVect lyr) {

		// TODO Auto-generated method stub

		this.firstLayer = lyr;

	}

	public IMonitorableTask createTask() {

		final CancellableMonitorable cancelMonitor = createCancelMonitor();

		return new IMonitorableTask() {

			String CLIP_GEOP_MSG = PluginServices.getText(this, "Mensaje_clip");

			String CLIP_MESSAGE = PluginServices.getText(this,

					"Mensaje_procesando_clip_primero");

			String INTERS_MESSAGE = PluginServices.getText(this,

					"Mensaje_procesando_clip_segundo");

			String of = PluginServices.getText(this, "De");

			String currentMsg = CLIP_MESSAGE;

			private boolean finished = false;

			public int getInitialStep() {

				return cancelMonitor.getInitialStep();

			}

			public int getFinishStep() {

				return cancelMonitor.getFinalStep();

			}

			public int getCurrentStep() {

				return cancelMonitor.getCurrentStep();

			}

			public String getStatusMessage() {

				return CLIP_GEOP_MSG;

			}

			public String getNote() {

				return currentMsg + " " + getCurrentStep() + " " + of + " "

						+ getFinishStep();

			}

			public void cancel() {

				((DefaultCancellableMonitorable) cancelMonitor)

						.setCanceled(true);

				ClipProcess.this.cancel();

			}

			public void run() {

				Geometry clippingGeometry = null;

				try {

					clippingGeometry = computeJtsClippingPoly();

				} catch (Exception e) {

					e.printStackTrace();

				}

				currentMsg = INTERS_MESSAGE;

				visitor = new ClipVisitor(clippingGeometry,

						resultLayerDefinition, schemaManager, writer);

				Strategy strategy = StrategyManager.getStrategy(firstLayer);

				Rectangle2D clippingRect = FConverter

						.convertEnvelopeToRectangle2D(clippingGeometry

								.getEnvelopeInternal());

				try {

					if (bitset!=null){

						visitor.setSelection(bitset);

					}

					strategy.process(visitor, clippingRect, cancelMonitor);

				} catch (Exception e) {

					e.printStackTrace();

				}

				finished = true;

			}

			public boolean isDefined() {

				return cancelMonitor.isDeterminatedProcess();

			}

			public boolean isCanceled() {

				return cancelMonitor.isCanceled();

			}

			public boolean isFinished() {

				return finished;

			}

		};

	}

	private Geometry computeJtsClippingPoly()

			throws com.iver.cit.gvsig.fmap.DriverException, VisitException {

		ScalableUnionVisitor visitor = new ScalableUnionVisitor();

		Strategy strategy = StrategyManager.getStrategy(auxLayer);

		if (onlyClipLayerSelection) {

			strategy.process(visitor, auxLayer.getRecordset().getSelection());

		} else {

			strategy.process(visitor);

		}

		return visitor.getJtsConvexHull();

	}

	public void setResultLayerProperties(IWriter writer,

			ISchemaManager schemaManager) {

		this.writer = writer;

		this.schemaManager = schemaManager;

	}

	private DefaultCancellableMonitorable createCancelMonitor() {

		DefaultCancellableMonitorable monitor = new DefaultCancellableMonitorable();

		monitor.setInitialStep(0);

		monitor.setDeterminatedProcess(true);

		int clipSteps = 0;

		try {

			if (onlyClipLayerSelection) {

				FBitSet selection = auxLayer.getRecordset().getSelection();

				clipSteps = selection.cardinality();

			} else {

				clipSteps = auxLayer.getSource().getShapeCount();

			}

			int firstSteps = 0;

			if (onlyFirstLayerSelection) {

				FBitSet selection = firstLayer.getRecordset().getSelection();

				firstSteps = selection.cardinality();

			} else {

				firstSteps = firstLayer.getSource().getShapeCount();

			}

			int totalSteps = clipSteps + firstSteps;

			monitor.setFinalStep(totalSteps);

		} catch (DriverException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (DriverIOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return monitor;

	}

	public ILayerDefinition getResultLayerDefinition() {

		return resultLayerDefinition;

	}

	public void setResultLayerDefinition(ILayerDefinition resultLayerDefinition) {

		this.resultLayerDefinition = resultLayerDefinition;

	}

}

package es.prodevelop.gvsig.exportMobile.layerexporters.clip;

import java.io.File;

import javax.swing.JOptionPane;

import com.iver.utiles.swing.threads.IMonitorableTask;

import com.iver.utiles.swing.threads.MonitorableDecoratorMainFirst;

import es.prodevelop.gvsig.exportMobile.files.NewDir;

public class PostProcessMonitorableDecoratorMainFirst extends

		MonitorableDecoratorMainFirst {

	private File tempFile, finalFile;

	public PostProcessMonitorableDecoratorMainFirst(

			IMonitorableTask mainTask,

			IMonitorableTask secondaryTask,

			File tmp, File finalf){

		super(mainTask, secondaryTask);

		tempFile = tmp;

		finalFile = finalf;

	}

	private void postProcess() {

		NewDir.copyShpDbfShxTempToFinal(tempFile, finalFile);

	}

	public void run() throws Exception {

		super.run();

		postProcess();

	}

}

package es.prodevelop.gvsig.exportMobile.layerexporters;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import org.apache.log4j.Logger;

import com.hardcode.driverManager.Driver;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.raster.CmsRasterDriver;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrRaster;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.rendering.XmlBuilder;

import com.iver.utiles.swing.threads.AbstractMonitorableTask;

import es.prodevelop.gvsig.exportMobile.xml.XmlProjectTags;

/**

 * Exportation subtask

 * Allows a raster layer to be exported

 * 

 * @author jcarras

 *

 */

public class RasterExporter extends ExporterSubTask{

	private Logger logger = Logger.getLogger(RasterExporter.class.getClass());

	private File outputdir;

	private static int INDX_PATH = 10;

	private FLyrRaster inLyrRast;

	/**

	 * COnstructor with all the needed attributes

	 * 

	 * @param parentProcess

	 * @param layer

	 * @param rect this parameter is not used currently

	 * @param outputdir

	 * @param xml

	 */

	public RasterExporter(AbstractMonitorableTask parentProcess, FLayer layer,

			Rectangle2D rect, File outputdir, XmlBuilder xml) {

		super(parentProcess, layer, rect, xml);

		this.outputdir=outputdir;

		inLyrRast = (FLyrRaster)layer;

	}

	/**

	 * Get old path file, and copy this file to a new file

	 */

	public void export() {

		setNote(PluginServices.getText(this, "exporting_")  + " " +  inLayer.getName());

		try {

			/*String pathLayer = inLayer.getXMLEntity().getXmlTag()

			.getProperty(INDX_PATH).getValue();

			File oldFile = new File(pathLayer);*/

			Driver driver =  inLyrRast.getSource().getDriver();

			if (driver instanceof CmsRasterDriver){

				initXML();

				CmsRasterDriver drR =(CmsRasterDriver)driver;

				File oldFile = drR.getFile();

				if (oldFile.exists()) {

					File destFile = new File(outputdir + File.separator + oldFile.getName());

					destFile = getFreeFile(destFile);

					File wldFile = findWldFile(oldFile);

					if (wldFile == null) {

						logger.warn("Did not find world file for: " + oldFile.getName());

					} else {

						String newWldPath = destFile.getAbsolutePath();

						newWldPath = newWldPath.substring(0, newWldPath.lastIndexOf("."));

						File newWldFile = new File(newWldPath + ".wld");

						copyFileToFile(wldFile, newWldFile, 5);

					}

					copyFileToFile(oldFile, destFile, 95);

					writeXML(inLayer.getName(), destFile.getName());

				}

			}

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} finally {

			closeXML();

			reportToEnd();

		}

	}

	/**

	 * Searches the WLD file associated with the layer

	 * 

	 * @param img_file

	 * @return

	 */

	private File findWldFile(File img_file) {

		String img_path = img_file.getAbsolutePath();

		String img_name = img_file.getName();

		int lastp = img_name.lastIndexOf(".");

		String img_name_no_ext = img_name.substring(0, lastp); 

		String ext = img_path.substring(img_path.length() - 4, img_path.length());

		File resp = null;

		if ((ext.compareToIgnoreCase(".jpg") == 0) || (ext.compareToIgnoreCase("jpeg") == 0)) {

			resp = new File(img_file.getParent() + File.separator + img_name_no_ext + ".jgw");

			if (resp.exists()) return resp;

			resp = new File(img_file.getParent() + File.separator + img_name_no_ext + ".jpw");

			if (resp.exists()) return resp;

			resp = new File(img_file.getParent() + File.separator + img_name_no_ext + ".jpgw");

			if (resp.exists()) return resp;

		}

		if ((ext.compareToIgnoreCase(".tif") == 0) || (ext.compareToIgnoreCase("tiff") == 0)) {

			resp = new File(img_file.getParent() + File.separator + img_name_no_ext + ".tfw");

			if (resp.exists()) return resp;

		}

		resp = new File(img_file.getParent() + File.separator + img_name_no_ext + ".wld");

		if (resp.exists()) return resp;

		return null;

	}

	/**

	 * Copies the in file to the outdir directory

	 * 

	 * @param in

	 * @param outdir

	 * @param numStepsToReport the copy will report this number of steps

	 * @throws Exception

	 */

	public void copyFileToDir(File in, File outdir, int numStepsToReport) throws Exception {

		File f = new File(outdir.getAbsolutePath() + File.separator + in.getName());

		copyFileToFile(in, f, numStepsToReport);

	}

	/**

	 * Copies the in file data to the outFile file

	 * 

	 * @param in

	 * @param outFile

	 * @param numStepsToReport the copy will report this number of steps

	 * @throws Exception

	 */

	public void copyFileToFile(File in, File outFile, int numStepsToReport) throws Exception {

		File f = outFile;

		long flenght = in.length();

		int currStep = 0;

		long bytesPerStep = flenght / numStepsToReport;

		long bytesCopied = 0;

		FileInputStream fis = new FileInputStream(in);

		FileOutputStream fos = new FileOutputStream(f);

		byte[] buf = new byte[1024];

		int i = 0;

		while ((i = fis.read(buf)) != -1) {

			fos.write(buf, 0, i);

			bytesCopied+=i;

			int newStep = (int)(bytesCopied / bytesPerStep);

			if (newStep>currStep){

				reportSteps(newStep-currStep);

				currStep=newStep;

			}

		}

		fis.close();

		fos.close();

	}

	/**

	 * Number of steps this subtask report

	 */

	public int getFinalStep() {

		return 100;

	}

	/**

	 * runs the exportation

	 */

	public void run() {

		export();

	}

	/**

	 * Writes the layer attributes on the gvsig mobile xml project file 

	 * 

	 * @param name

	 * @param path

	 */

	private void writeXML(String name, String path){

		//<Type>

		xml.writeTag(XmlProjectTags.TYPE, "RASTER");

		//</Type>

		//<Path>

		xml.writeTag(XmlProjectTags.PATH, path);

		//</Path>

		//<Name>

		xml.writeTag(XmlProjectTags.NAME, name);

		//</Name>

	}

}

package es.prodevelop.gvsig.exportMobile.layerexporters;

import java.awt.geom.Rectangle2D;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.rendering.XmlBuilder;

import com.iver.utiles.swing.threads.AbstractMonitorableTask;

import es.prodevelop.gvsig.exportMobile.xml.XMLwms;

/**

 * Exports a gvsig wms layer to a gvsig mobile wms layer

 * @author Anabel Moreno

 *

 */

public class WMSExporter extends ExporterSubTask{

	/**

	 * Constructor with all the required attributes

	 * @param parentProcess

	 * @param layer

	 * @param rect

	 * @param xml

	 */

	public WMSExporter(AbstractMonitorableTask parentProcess, FLayer layer,

			Rectangle2D rect, XmlBuilder xml) {

		super(parentProcess, layer, rect, xml);

	}

	/**

	 * Adds to the xml the layer attributes

	 */

	public void export(){

		initXML();

		setNote(PluginServices.getText(this, "exporting_")  + " " +  inLayer.getName());

		XMLwms xmlwms = new XMLwms();

		xmlwms.setxml(inLayer,xml);

		xmlwms.createXML();

		reportToEnd();

		closeXML();

	}

	/**

	 * Number of steps the layer will report

	 */

	public int getFinalStep() {

		return 100;

	}

	/**

	 * Starts the exportation task

	 */

	public void run() {

		export();

	}

}

package es.prodevelop.gvsig.exportMobile.layerexporters;

import java.awt.geom.Rectangle2D;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.rendering.XmlBuilder;

import com.iver.utiles.swing.threads.AbstractMonitorableTask;

import es.prodevelop.gvsig.exportMobile.xml.Bounds;

import es.prodevelop.gvsig.exportMobile.xml.XmlProjectTags;

/**

 * 

 * This  process executes a series of tasks

 * 

 * @author jcarras

 *

 */

public class ExportProcess  extends AbstractMonitorableTask{

	private ArrayList tasks = new ArrayList();

	private int numSteps=0;

	private XmlBuilder xml = new XmlBuilder();

	private Rectangle2D rect;

	private String name;

	private IProjection projection;

	private String dirPath;

	public static String PROJECTEXTENSION = ".gvm";

	/**

	 * Constructor with all needed parameters 

	 * @param rectangle

	 * @param name

	 * @param dirPath

	 * @param projection

	 */

	public ExportProcess(Rectangle2D rectangle, String name, String dirPath, IProjection projection){

		setRect(rectangle);

		setName(name);

		setProjection(projection);

		setDirPath(dirPath);

	}

	/**

	 * Adds a ExporterSubTask task to the list of task to execute

	 * The order the tasks are added is the order they will be executed

	 * @param task

	 */

	public void addTask(ExporterSubTask task){

		tasks.add(task);

		numSteps+=task.getFinalStep();