/ - Diff - Application: gvSIG desktop - gvSIG

     /**
      * Create a new directory
      * Manages the directory when a gvsig mobile project
      * with his data will be stored
+     *
      * @author Anabel Moreno
+     *
      */

     /**
      * This extension will be visible if any view is execute. Get the layers are in
      * TOC and the exents of the view to work with them.
      * If are any group of layers in TOC, we work with its layers as
      * if this gropu doesn?t exists.
+     *
      * 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() {
     //		//Initialiser SOAP writer with the desination SOAP file
     		//File destFile = new File("SOAPComEventModif.xml");
     		//CommMessageWriterManager.registerManager(new CommMessageWriterManager(new SOAPCommMessageWriter(destFile)));
+    	}
     	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();
-...
     		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();

trunk/prototypes/mobile/desktop/extensions/extExportMobile/src/es/prodevelop/gvsig/exportMobile/rectangle/DrawRectangle.java
19	19	import com.iver.cit.gvsig.project.documents.view.gui.View;
20	20
21	21	/**
22		* Draw a poligon with the same dimension that mapControl
	22	* Utility to create layers with rectangles
23	23	*
24	24	* @author Anabel Moreno
25	25	*

     import org.apache.log4j.Logger;
     /**
      * To create an Image Icon
      * Class to access the icons used by the extension
      * @author amoreno
+     *
      */
-...
     	 *            where the image is into.
     	 * @param description
     	 *            of the image.
     	 * @return
     	 * @return ImageIcon
     	 */
     	public ImageIcon createImageIcon(URL path, String description) {

     import es.prodevelop.gvsig.exportMobile.xml.XMLwms;
     /**
      * Create a new xml file with the WMSCONFIG into the output directory selected
      * 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);
-...
     	/**
     	 * export the new xml file
     	 * @param layerWMS
     	 * @param outfile
     	 * @param boxWMS
     	 * Adds to the xml the layer attributes
     	 */
     	public void export(){
     		initXML();
-...
     		closeXML();
+    	}
     	@Override
     	/**
     	 * Number of steps the layer will report
     	 */
     	public int getFinalStep() {
     		// TODO Auto-generated method stub
     		return 100;
+    	}
     	@Override
     	/**
     	 * Starts the exportation task
     	 */
     	public void run() {
     		// TODO Auto-generated method stub
     		export();
+    	}
+    }

     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{
     /**
      *  This process executes a series of tasks
      */
     	private ArrayList tasks = new ArrayList();
     	private int numSteps=0;
     	private XmlBuilder xml = new XmlBuilder();
-...
     	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);
-...
     		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,
-...
     		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
-...
     		createFile(fileout,xml.getXML());
+    	}
     	/**
     	 * Starts the xml to be ready for pushing the layers into
     	 */
     	private void initProjectFile(){
     		xml.writeHeader();
     		//<Project>
-...
     			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();
-...
     		reportToEnd();
+    	}
     	/**
     	 * Reports steps to indicate the task list has been completed
     	 */
     	private void reportToEnd(){
     		while (getCurrentStep()<getFinalStep())
     			reportStep();
+    	}
     	public Rectangle2D getRect() {
     		return rect;
+    	}
-...
     		this.dirPath = dirPath;
+    	}
     	/**
     	 * Writes the xml to the file
+    	 *
     	 * @param f
     	 * @param xml
     	 */
     	public static void createFile(File f, String xml) {
     		if (xml != null) {
     			try {

     import es.prodevelop.gvsig.exportMobile.xml.Style;
     import es.prodevelop.gvsig.exportMobile.xml.XmlProjectTags;
     /**
      * Exportation subtask to export a vectorial layer
      * It supports selecting features by rect, clipping
      * features by rect and exporting all features
      * It splits the input data in polygons, lines and
      * points to save it as shapefiles.
+     *
      * @author jcarras
+     *
      */
     public class VectorialExporterTask extends ExporterSubTask {
     	public static final int CLIPRECT = 1;
-...
     	public static final  String NOSUFFIX = "";
     	public static final  String SHAPESUFFIX = ".shp";
     	/**
     	 * Returns the suffix associated wit the input process type
     	 * @param processType
     	 * @return the corresponding suffix
     	 */
     	public String getSuffix(int processType){
     		if (processType == CLIPRECT)
     			return CLIPSUFFIX;
-...
     		return NOSUFFIX;
+    	}
     	/**
     	 * Remove the defined suffixes of the input string with the objective
     	 * of not adding twice the suffixes on several exportations
+    	 *
     	 * @param name
     	 * @return the input string without the suffixes
     	 */
     	public String removeSuffixes(String name){
     		String res = name;
-...
     	private Logger logger = Logger.getLogger(this.getClass());
     /**
      * Constructor with all the needed attributes
      * @param parentProcess
      * @param layer
      * @param rect
      * @param destPath
      * @param processType One of those VectorialExporterTask.CLIPRECT, VectorialExporterTask.ALL or VectorialExporterTask.SELECTRECT
      * @param fieldsDescription Description of the fields of the resulting layers
      * @param xml
      */
     	public VectorialExporterTask(AbstractMonitorableTask parentProcess,
     			FLayer layer, Rectangle2D rect, String destPath, int processType,
     			FieldDescription[] fieldsDescription, XmlBuilder xml) {
-...
+    	}
     	public void clipFeatures(IWriter writer, Driver reader, FBitSet bitSet, ShpSchemaManager schemaManager, ILayerDefinition outputDef, int numStepsToReport){
     	private void clipFeatures(IWriter writer, Driver reader, FBitSet bitSet, ShpSchemaManager schemaManager, ILayerDefinition outputDef, int numStepsToReport){
     		ClipProcess clip = new ClipProcess(
     				inLayerVec,
     				fieldsDescription, bitSet);
-...
+    	}
     	/**
     	 * Makes the exportation
     	 */
     	public void  export() {
     		setNote(PluginServices.getText(this, "exporting_") + " " + inLayer.getName());
-...
+    	}
     	/**
     	 * It iterates over every feature to return a bitSet with the features of
     	 * the input type and inside the input rectangle
     	 * @param rect
     	 * @param type
     	 * @return
     	 * @throws DriverException
     	 */
     	public FBitSet queryByRectAndType(Rectangle2D rect, int type)
     			throws DriverException {
-...
+    	}
     	/**
     	 * @param file
     	 * @return
     	 * @throws IOException
     	 */
     	public IndexedShpDriver getOpenShpDriver(File file) throws IOException {
     	private IndexedShpDriver getOpenShpDriver(File file) throws IOException {
     		IndexedShpDriver drv = new IndexedShpDriver();
     		if (!file.exists()) {
-...
     		return drv;
+    	}
     	/**
     	 * Name agreed with descripExLyr2
+    	 *
     	 * @param sds2
     	 * @param descripExLyr2
     	 * @param i
     	 * @return
     	 * @throws com.hardcode.gdbms.engine.data.driver.DriverException
     	 */
     	private Value[] extractValues(SelectableDataSource sds2,
     			FieldDescription[] descripExLyr2, int i)
     			throws com.hardcode.gdbms.engine.data.driver.DriverException {
-...
     		return index;
+    	}
     	@Override
     	/**
     	 * Number of steps the Exportation will report
     	 */
     	public int getFinalStep() {
     		return 100;
+    	}
     	@Override
     	/**
     	 * Runs the exportation task
     	 */
     	public void  run() {
     		export();
+    	}
     	/**
     	 * Writes the layer attributes to the input xml
     	 * @param name
     	 * @param shpType
     	 * @param path
     	 */
     	private void writeXML(String name, int shpType, String path){
     		//xml.openTag(XmlProjectTags.LAYER);
     		//<Type>

     import es.prodevelop.gvsig.exportMobile.xml.XmlProjectTags;
     /**
+     *
      * This class mother has to be the ancestor of every class
      * executable in an ExportProcess
+     *
      * @author jcarras
+     *
      */
-...
     	private int currentStep = 0;
     	private boolean isCancelled = false;
     	private ExporterSubTask(){
+    	}
     	public abstract void run();
     	/**
     	 * Constructor
+    	 *
     	 * @param parentProcess
     	 * @param layer
     	 * @param rect
     	 * @param xml
     	 */
     	public ExporterSubTask(AbstractMonitorableTask parentProcess, FLayer layer, Rectangle2D rect, XmlBuilder xml){
     		this.inLayer=layer;
     		this.rect=rect;
-...
     		this.xml=xml;
+    	}
     	/**
     	 * Indicates to the ExportProcess that the task is going on
     	 * reportStep has to be called exactly getFinalStep() times
     	 */
     	public void reportStep(){
     		currentStep++;
     		parent.reportStep();
+    	}
     	/**
     	 * It reports numSteps Steps
     	 * @param numSteps
     	 */
     	public void reportSteps(int numSteps){
     		for (int i=0; i<numSteps; i++)
     			reportStep();
+    	}
     	/**
     	 * Changes the status text of the task
     	 * @param statusMessage
     	 */
     	public void setStatusMessage(String statusMessage){
     		parent.setStatusMessage(statusMessage);
+    	}
     	/**
     	 * Changes the note of the task
     	 * (It is showed on progress dialog)
+    	 *
     	 * @param note
     	 */
     	public void setNote(String note){
     		parent.setNote(note);
+    	}
     	/**
     	 * Any class extending ExporterSubClass has to implement this method
     	 * to comunicate the number of steps it will report
     	 * @return
     	 */
     	public abstract int getFinalStep();
     	/**
     	 * If the proposed file exists, this method returns one not existing
     	 * file similar to the proposed one
+    	 *
     	 * @param proposedFile
     	 * @return
     	 */
     	public File getFreeFile(File proposedFile){
     		if (!proposedFile.exists())
     			return proposedFile;
-...
     		return null;
+    	}
     	/**
     	 * Starts the XML with the layer heading
     	 */
     	protected void initXML(){
     		//<Layer>
     		xml.openTag(XmlProjectTags.LAYER);
     		xmlInited=true;
+    	}
     	/**
     	 * Add the layer footer to the XML
     	 */
     	protected void closeXML(){
     		if (isXmlInited())
     			xml.closeTag();

     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 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);
-...
+    	}
     	/**
     	 * Searches the WLD file associated with the layer
+    	 *
     	 * @param img_file
     	 * @return
     	 */
     	private File findWldFile(File img_file) {
     		String img_path = img_file.getAbsolutePath();
-...
+    	}
     	/**
     	 * Create the new output file in output file
     	 * Copies the in file to the outdir directory
+    	 *
     	 * @param in,
     	 *            old file
     	 * @param outdir,
     	 *            output dir
     	 * @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());
     		/*
     		long flenght = f.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();*/
     		copyFileToFile(in, f, numStepsToReport);
+    	}
     	/**
     	 * Create the new output file in output file
     	 * Copies the in file data to the outFile file
+    	 *
     	 * @param in,
     	 *            old file
     	 * @param outdir,
     	 *            output dir
     	 * @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 {
-...
+    	}
     	@Override
     	/**
     	 * Number of steps this subtask report
     	 */
     	public int getFinalStep() {
     		// TODO Auto-generated method stub
     		return 100;
+    	}
     	@Override
     	/**
     	 * 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");

Application: gvSIG desktop

Revision 19196