| gvSIG desktop 1

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

public class XmlProjectTags {

	private XmlProjectTags(){};

	public static final String PROJECT = "Project";

	public static final String B_BOX = "BoundingBox";

	public static final String X_MIN = "xMin";

	public static final String X_MAX = "xMax";

	public static final String Y_MIN = "yMin";

	public static final String Y_MAX = "yMax";

	public static final String NAME = "Name";

	public static final String VISIBLE = "Visible";

	public static final String SCALE_MAX = "ScaleMax";

	public static final String SCALE_MIN = "ScaleMin";

	public static final String LAYERS = "Layers";

	public static final String LAYER = "Layer";

	public static final String TYPE = "Type";

	public static final String PATH = "Path";

	public static final String STYLE = "Style";

	public static final String POINT_SYMBOL = "PointSymbol";

	public static final String LINE_SYMBOL = "LineSymbol";

	public static final String POLYGON_SYMBOL = "PolygonSymbol";

	public static final String COLOR = "Color";

	public static final String SIZE = "Size";

	public static final String FILL_COLOR = "FillColor";

	public static final String FILL = "Fill";

	public static final String WMSCONFIG = "WMSConfig";

	public static final String LAYER_NAME = "LayerName";

	public static final String URL = "URL";

	public static final String LAYERQUERY = "LayerQuery";

	// public static final String SRS = "SRS";

	public static final String IMAGE_FORMAT = "ImageFormat";

	public static final String TRANSPARENCY = "Transparency";

	public static final String WMSLAYERS = "WmsLayers";

	public static final String WSMSTYLES = "WmsStyles";

	public static final String CRS = "CRS";

}

package es.prodevelop.gvsig.exportMobile.xml;

import java.awt.BasicStroke;

import java.awt.Color;

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

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

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

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

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

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

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

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

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

import com.iver.utiles.StringUtilities;

/**

 * 

 * @author amoreno

 *

 */

public class XMLlyr {

	private FLayer layer;

	private String color;

	private String colorFill;

	private int size;

	private int fill;

	public  XMLlyr(){

	}

	public String getColor(){

		return this.color;

	}

	public int getSize(){

		return this.size;

	}

	public int getFill(){

		return this.fill;

	}

	public String getColorFill(){

		return this.colorFill;

	}

	public void createTextToXML(FLayer lyr, int shpType){

		layer = lyr;

		if(layer instanceof FLyrVect){

			FLyrVect layerV = (FLyrVect) layer;

			try {

				FSymbol symbol = null;

				if (shpType == FShape.LINE) {

					VectorialLegend vleg = (VectorialLegend)layerV.getLegend();

					if (vleg instanceof SingleSymbolLegend){

						symbol = (FSymbol)((SingleSymbolLegend)vleg).getDefaultSymbol();

					}

					//tomar de vectorialintervallegend y vectorialuniquevaluelegend el primer valor

					//como symbol, y luego de symbol obtener lo que necesitemos

					if(vleg instanceof VectorialIntervalLegend){

						symbol = (FSymbol)((VectorialIntervalLegend)vleg).getSymbol(0);

					}

					if(vleg instanceof VectorialUniqueValueLegend){

						symbol = (FSymbol)((VectorialUniqueValueLegend)vleg).getSymbol(0);

					}

					Color col=symbol.getColor();

					this.color = StringUtilities.color2String(col);

					// instead of symbol.getSize(), we have to use this:

					// jldominguez

					int stroke_width = Math.round(((BasicStroke) symbol.getStroke()).getLineWidth());

					this.size = stroke_width;

				}

				if(shpType == FShape.POINT){

					VectorialLegend vleg = (VectorialLegend)layerV.getLegend();

					if (vleg instanceof SingleSymbolLegend){

						symbol = (FSymbol)((SingleSymbolLegend)vleg).getDefaultSymbol();

					}

					//tomar de vectorialintervallegend y vectorialuniquevaluelegend el primer valor

					//como symbol, y luego de symbol obtener lo que necesitemos

					if(vleg instanceof VectorialIntervalLegend){

						symbol = (FSymbol)((VectorialIntervalLegend)vleg).getSymbol(0);

					}

					if(vleg instanceof VectorialUniqueValueLegend){

						symbol = (FSymbol)((VectorialUniqueValueLegend)vleg).getSymbol(0);

					}

					Color col=symbol.getColor();

					this.color = StringUtilities.color2String(col);

					// instead of symbol.getSize(), we have to use this:

					// jldominguez

					if (symbol.isSizeInPixels()) {

						size = symbol.getSize();

					} else {

						// TODO calcular el tamanyo en pixeles

						size = 3;

					}

				}

				if(shpType == FShape.POLYGON){

					VectorialLegend vleg = (VectorialLegend)layerV.getLegend();

					if (vleg instanceof SingleSymbolLegend){

						symbol = (FSymbol)((SingleSymbolLegend)vleg).getDefaultSymbol();

					}

					//tomar de vectorialintervallegend y vectorialuniquevaluelegend el primer valor

					//como symbol, y luego de symbol obtener lo que necesitemos

					if(vleg instanceof VectorialIntervalLegend){

						symbol = (FSymbol)((VectorialIntervalLegend)vleg).getSymbol(0);

					}

					if(vleg instanceof VectorialUniqueValueLegend){

						symbol = (FSymbol)((VectorialUniqueValueLegend)vleg).getSymbol(0);

					}

					Color colFill=symbol.getColor();

					// there was a np exception when polygons were not filled

					// jldominguez

					if (colFill == null) {

						this.colorFill = StringUtilities.color2String(Color.WHITE);

						fill = 0;

					} else {

						this.colorFill = StringUtilities.color2String(colFill);

						fill = 1;

					}

					// instead of symbol.getSize(), we have to use this:

					// jldominguez

					int stroke_width = Math.round(((BasicStroke) symbol.getStroke()).getLineWidth());

					this.size = stroke_width;

					Color col = symbol.getOutlineColor();

					// there was a np exception when polygons were not filled

					// jldominguez

					if (col == null) {

						this.color = StringUtilities.color2String(Color.BLACK);

					} else {

						this.color = StringUtilities.color2String(col);

					}

					/*

					int symboltype = symbol.getSymbolType();

					FConstant f = null;

					if(symboltype == f.SYMBOL_TYPE_FILL)

						this.fill=1;

					else

						this.fill=0;

						*/	

				}

			} catch (IndexOutOfBoundsException e) {

				e.printStackTrace();

			} catch (DriverException e) {

				e.printStackTrace();

			}

		}		

	}	

}

package es.prodevelop.gvsig.exportMobile.xml;

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

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

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

import com.iver.utiles.xmlEntity.generate.Property;

/**

 * get wms layer properties and create its xml project

 * @author Anabel Moreno

 *

 */

public class XMLwms implements XMLgetter{

	private static int NAME = 2;

	private static int URL = 10;

	private static int LAYERQUERY = 12;

	private static int CAPLAYERSTYLES = 21;

	private static int CRS = 14;

	private static int IMAGEFORMAT = 13;

	private static int TRANSPARENCY = 6;

	XmlBuilder xml;

	private FLayer layerWMS;

	public void setxml(FLayer layerwn,XmlBuilder xml_builder){

		this.layerWMS = layerwn;

		this.xml = xml_builder;

	}

	public void createXML(){

		Property[] pr;

		try {

			pr = layerWMS.getXMLEntity().getXmlTag().getProperty();

			//<WMSCONFIG>

			//xml.openTag(XmlProjectTags.WMSCONFIG);

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

				//<LAYERNAME>

				xml.writeTag(XmlProjectTags.NAME, layerWMS.getName());

				//</LAYERNAME>

				//<URL>

				xml.writeTag(XmlProjectTags.URL,pr[URL].getValue());

				//</URL>

				//<LAYERQUERY>

				//xml.openTag(XmlProjectTags.LAYERQUERY);

					//<NAME>

					xml.writeTag(XmlProjectTags.WMSLAYERS, pr[LAYERQUERY].getValue());

					//</NAME>

					//<STYLE>

					xml.writeTag(XmlProjectTags.WSMSTYLES,pr[CAPLAYERSTYLES].getValue());

					//</STYLE>

				//xml.closeTag();

				//</LAYERQUERY>

				//<SRS>

				xml.writeTag(XmlProjectTags.CRS, pr[CRS].getValue());

				//</SRS>

				//<IMAGEFORMAT>

				xml.writeTag(XmlProjectTags.IMAGE_FORMAT, pr[IMAGEFORMAT].getValue());

				//</IMAGEFORMAT>

				//<TRANSPARENCY>

				xml.writeTag(XmlProjectTags.TRANSPARENCY,pr[TRANSPARENCY].getValue());

				//</TRANSPARENCY>

			//xml.closeTag();

			//</WMSCONFIG>

		} catch (XMLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

}

package es.prodevelop.gvsig.exportMobile.xml;

import java.awt.geom.Rectangle2D;

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

/**

 * Get bounds of view and create new tags to the xml project

 * @author Anabel Moreno

 *

 */

public class Bounds extends Rectangle2D.Double implements XMLgetter {

	public static final String tag = "bounds";

	public XmlBuilder xml;

	public static Bounds createBounds(Rectangle2D rect){

		Bounds bounds = new Bounds();

		bounds.setRect(rect);

		return bounds;

	}

	public void setXML(XmlBuilder xml_builder){

		this.xml = xml_builder;

	}

	public void createXML(){

		//<Bounds>

		xml.openTag(XmlProjectTags.B_BOX);

			//<xMin>

			xml.writeTag(XmlProjectTags.X_MIN,java.lang.Double.toString(this.getMinX()));

			//</xMin>

			//<xMax>

			xml.writeTag(XmlProjectTags.X_MAX,java.lang.Double.toString(this.getMaxX()));

			//</xMax>

			//<yMin>

			xml.writeTag(XmlProjectTags.Y_MIN,java.lang.Double.toString(this.getMinY()));

			//</yMin>

			//<yMax>

			xml.writeTag(XmlProjectTags.Y_MAX,java.lang.Double.toString(this.getMaxY()));

			//</yMax>

		xml.closeTag();

		//</Bounds>

	}

}

package es.prodevelop.gvsig.exportMobile.xml;

public interface XMLgetter {

	void createXML();

}

package es.prodevelop.gvsig.exportMobile.xml;

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

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

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

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

/**

 * Get style of a layer, and create a new tag

 * @author Anabel Moreno

 *

 */

public class Style implements XMLgetter{

	FLayer lyr;

	String color;

	String colorFill;

	int size;

	int fill;

	XmlBuilder xml;

	int shpType;

	public void setXML(XmlBuilder xml_builder){

		this.xml = xml_builder;

	}

	public void setLayer(FLayer layer, int shpType){

		this.lyr = layer;

		this.shpType=shpType;

	}

	public void createXML(){

		XMLlyr xmlyr = new XMLlyr();

		xmlyr.createTextToXML(lyr, shpType);

		FLyrVect lyrV = (FLyrVect) lyr;

		//<Style>

		xml.openTag(XmlProjectTags.STYLE);

		//try {

			if(shpType == FShape.POINT){

				//<PointSymbol>

				xml.openTag(XmlProjectTags.POINT_SYMBOL);

					//<Color>

					xml.writeTag(XmlProjectTags.COLOR, xmlyr.getColor());

					//</Color>

					//<Size>

					xml.writeTag(XmlProjectTags.SIZE, java.lang.Integer.toString(xmlyr.getSize()));

					//</Size>

				xml.closeTag();

				//</PointSymbol>

			}

			if(shpType == FShape.LINE){

				//<LineSymbol>

				xml.openTag(XmlProjectTags.LINE_SYMBOL);

					//<Color>

					xml.writeTag(XmlProjectTags.COLOR, xmlyr.getColor());

					//</Color>

					//<Size>

					xml.writeTag(XmlProjectTags.SIZE, java.lang.Integer.toString(xmlyr.getSize()));

					//</Size>

				xml.closeTag();

				//</LineSymbol>

			}

			if(shpType == FShape.POLYGON){

				//<PoligonSymbol>

				xml.openTag(XmlProjectTags.POLYGON_SYMBOL);

					//<LineSymbol>

					xml.openTag(XmlProjectTags.LINE_SYMBOL);

						//<Color>

						xml.writeTag(XmlProjectTags.COLOR, xmlyr.getColor());

						//</Color>

						//<Size>

						xml.writeTag(XmlProjectTags.SIZE, java.lang.Integer.toString(xmlyr.getSize()));

						//</Size>

					xml.closeTag();

					//</LineSymbol>

					//<FillColor>

					xml.writeTag(XmlProjectTags.FILL_COLOR, xmlyr.getColorFill());

					//</FillColor>

					//<Fill>

					xml.writeTag(XmlProjectTags.FILL, java.lang.Integer.toString(xmlyr.getFill()));

					//</FillColor>

				xml.closeTag();

				//</PoligonSymbol>

			}

		/*} catch (DriverException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}*/

		xml.closeTag();

		//</Style>

	}

}

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;

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();

	}

	/**

	 * Creates a VectorialExporterTask and adds it to the list of tasks to execute

	 * @param lyr

	 * @param outputFields

	 * @param processType

	 */

	public void addVectorialTask(FLayer lyr, FieldDescription[] outputFields, int processType){

		VectorialExporterTask task = new VectorialExporterTask(this,

				lyr,

				getRect(),

				dirPath,

				processType,

				outputFields,

				xml);

		addTask(task);

	}

	/**

	 * Creates a RasterExporter task and adds it to the list of tasks to execute

	 * @param lyr

	 */

	public void addRasterTask(FLayer lyr){

		RasterExporter task = new RasterExporter(this,lyr,rect, new File(dirPath),xml);

		addTask(task);

	}

	/**

	 * Creates a WMSExporter task and adds it to the list of tasks to execute

	 * @param lyr

	 */

	public void addWMSTask(FLayer lyr){

		WMSExporter task = new WMSExporter(this,lyr,getRect(),xml);

		addTask(task);

	}

	/**

	 * Closes the oppened xml tags and stores the project file

	 */

	private void writeProjectFile(){

		// done

		xml.closeTag();

		//</Layers>

		xml.closeTag();

		//</Project>

		//new file

		File fileout = new File(dirPath+ File.separator + name + PROJECTEXTENSION);

		createFile(fileout,xml.getXML());

	}

	/**

	 * Starts the xml to be ready for pushing the layers into

	 */

	private void initProjectFile(){

		xml.writeHeader();

		//<Project>

		xml.openTag(XmlProjectTags.PROJECT);

		Bounds bounds = Bounds.createBounds(rect);

			//<BoundingBox>

			bounds.setXML(xml);

			bounds.createXML();

			//</BoundingBox>

			//<Name>

			xml.writeTag(XmlProjectTags.NAME, name);

			//<Name>

			//<CRS>

			String crsProyect = getProjection().getAbrev();

			xml.writeTag(XmlProjectTags.CRS, crsProyect);

			//</CRS>

			//<Layers>

			xml.openTag(XmlProjectTags.LAYERS);

	}

	/**

	 * To be executed before running this

	 */

	public void preProcess(){

		setInitialStep(0);

		this.setFinalStep(numSteps);

		setDeterminatedProcess(true);

	}

	/**

	 * Executes all the tasks in the list, creates the project file and 

	 * reports the steps not reported yet

	 */

	public void run() throws Exception {

		initProjectFile();

		for (int i=0; i<tasks.size(); i++){

			ExporterSubTask task = (ExporterSubTask)tasks.get(i);

			if (!isCanceled()){

				task.run();

			}else{

				task.setCancelled(true);

			}

		}

		setNote("Generating project file");

		writeProjectFile();

		JOptionPane.showMessageDialog(null,

				PluginServices.getText(this, "export_done") + "\n" + dirPath,

				PluginServices.getText(this, "exporMob"),

				JOptionPane.INFORMATION_MESSAGE);

		reportToEnd();

	}