/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 22037

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *   Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *   +34 963862235
      *   gvsig@gva.es
      *   http://www.gvsig.gva.es
+     *
      *    or
+     *
      *   Prodevelop Integraci?n de Tecnolog?as SL
      *   Conde Salvatierra de ?lava , 34-10
      *   46004 Valencia
      *   Spain
+     *
      *   +34 963 510 612
      *   +34 963 510 968
      *   gis@prodevelop.es
      *   http://www.prodevelop.es
+     *
      *    or
+     *
      *   Instituto de Rob?tica
      *   Apartado de correos 2085
      *   46071 Valencia
      *   (Spain)
+     *
      *   +34 963 543 577
      *   jjordan@robotica.uv.es
      *   http://robotica.uv.es
+     *
      */
     package org.gvsig.data.datastores.vectorial.file;
     import java.nio.ByteOrder;
     /**
      * This class replaces the byte buffer used in J2SE to store a file in memory.
+     *
      * @see java.nio.ByteOrder
+     *
      * @author jldominguez
+     *
      */
     public class FalseByteBuffer {
     	private byte[] bytes;
     	private ByteOrder byteOrder = ByteOrder.LITTLE_ENDIAN;
     	private int pos = 0;
     	/**
     	 * Constructor
     	 * @param bb array of bytes to be stored
     	 */
     	public FalseByteBuffer(byte[] bb) {
     		bytes = bb;
+    	}
     	/**
     	 * Moves file cursor to position p
     	 * @param p the new position
     	 */
     	public void position(int p) {
     		pos = p;
+    	}
     	/**
+    	 *
     	 * @return current cursor position
     	 */
     	public int getPosition() {
     		return pos;
+    	}
     	/**
     	 * @return byte pointed by cursor then increases cursor
     	 */
     	public byte getByte() {
     		byte resp = bytes[pos];
     		pos++;
     		return resp;
+    	}
     	/**
     	 * Gets one byte
     	 * @param ind index of the byte of interest
     	 * @return the byte of interest
     	 */
     	public byte getByte(int ind) {
     		return bytes[ind];
+    	}
     	/**
     	 * @return integer pointed by cursor then increases cursor
     	 */
     	public int getInt() {
     		int resp = getInt(bytes, pos);
     		pos = pos + 4;
     		return resp;
+    	}
     	/**
     	 * @return short pointed by cursor then increases cursor
     	 */
     	public short getShort() {
     		short resp = getShort(bytes, pos);
     		pos = pos + 2;
     		return resp;
+    	}
     	/**
     	 * Gets the integer at a certain position
     	 * @param index the index of interest
     	 * @return the integer at a certain position
     	 */
     	public int getInt(int index) {
     		int resp = getInt(bytes, index);
     		return resp;
+    	}
     	/**
     	 * Gets some bytes.
     	 * @param out the array of bytes to be filled
     	 */
     	public void getBytes(byte[] out) {
     		for (int i=0; i<out.length; i++) {
     			out[i] = getByte(pos + i);
+    		}
     		pos = pos + out.length;
+    	}
     	/**
     	 * @return double pointed by cursor then increases cursor
     	 */
     	public double getDouble() {
     		double resp = getDouble(bytes, pos);
     		pos = pos + 8;
     		return resp;
+    	}
     	private int getInt(final byte[] data, final int offset) {
             return (int) getNumber(data, offset, 4);
+        }
     	private short getShort(final byte[] data, final int offset) {
             return (short) getNumber(data, offset, 2);
+        }
     	private long getNumber(final byte[] data, final int offset, final int size) {
             long result = 0;
             if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
                 for (int j = offset + size - 1; j >= offset; j--) {
                     result <<= 8;
                     result |= 0xff & data[j];
+                }
             } else {
                 for (int j = offset; j <= offset + size - 1; j++) {
                     result <<= 8;
                     result |= 0xff & data[j];
+                }
+            }
             return result;
+        }
     	private double getDouble(final byte[] data, final int offset) {
             return Double.longBitsToDouble(getNumber(data, offset, 8));
+        }
     	/**
     	 * Sets byte order (big endian, little endian)
     	 * @param o byte order (big endian, little endian)
     	 */
     	public void setByteOrder(ByteOrder o) {
     		byteOrder = o;
+    	}
+    }

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *   Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *   +34 963862235
      *   gvsig@gva.es
      *   http://www.gvsig.gva.es
+     *
      *    or
+     *
      *   Prodevelop Integraci?n de Tecnolog?as SL
      *   Conde Salvatierra de ?lava , 34-10
      *   46004 Valencia
      *   Spain
+     *
      *   +34 963 510 612
      *   +34 963 510 968
      *   gis@prodevelop.es
      *   http://www.prodevelop.es
+     *
      *    or
+     *
      *   Instituto de Rob?tica
      *   Apartado de correos 2085
      *   46071 Valencia
      *   (Spain)
+     *
      *   +34 963 543 577
      *   jjordan@robotica.uv.es
      *   http://robotica.uv.es
+     *
      */
     package org.gvsig.data.datastores.vectorial.file;
     import java.awt.Container;
     import java.awt.Image;
     import java.awt.MediaTracker;
     import java.awt.Toolkit;
     import java.io.File;
     import org.apache.log4j.Logger;
     /**
      * Utility class to read resource files.
+     *
      * @see java.awt.MediaTracker
+     *
      * @author jldominguez
+     *
      */
     public class ResourceReader {
     	private static final String WORKSPACE = "D:/PROYECTOS/Filtros2/libFMap_data_shape";
     	private static Logger logger = Logger.getLogger(ResourceReader.class);
     	private static String resourceDir = "";
     	private static int IMAGE_LOAD_TIMEOUT = 1200;
     	/**
     	 * Icon shown while the app is processing.
     	 */
     	public static Image PROCESSING_ICON;
     	/**
     	 * Array of GPS icons (16 positions)
     	 */
     	public static Image[] GPS_CURSOR_ICON;
     	/**
     	 * number of positions of the GPS cursor
     	 */
     	public static int GPS_CURSOR_ICON_COUNT = 16;
     	public static int PROCESS_ICON_X = 90;
     	public static int PROCESS_ICON_Y = 105; //110;
     	public static int PROCESS_ICON_SIZE = 60;
     	/**
     	 * Used to read images
     	 */
     	public static MediaTracker mt = new MediaTracker(new Container());
     	public static int imageCount = 0;
     	static {
     		String base = System.getProperty("java.class.path");
     		int ind = base.indexOf(File.pathSeparator);
     		if (ind != -1) base = base.substring(0, ind);
     		ind = base.lastIndexOf(File.separator);
     		base = base.substring(0, ind);
     		//logger.debug("Base directory: " + base);
     		ind = base.lastIndexOf(File.separator);
     		resourceDir = base.substring(0, ind) + File.separator + "resources";
     		PROCESSING_ICON = getResourceImage("img", "processing.png");
     		GPS_CURSOR_ICON = new Image[GPS_CURSOR_ICON_COUNT];
     		for (int i=0; i<GPS_CURSOR_ICON_COUNT; i++) {
     			try {
     				GPS_CURSOR_ICON[i] = getResourceImage("img", "gps_cursor_" + i + ".png");
     			} catch (Exception ex) {
     				logger.error("Unable to read GPS icon # " + i + " : " + ex.getMessage());
+    			}
+    		}
+    	}
     	/**
     	 * Gets the GPS icon index  for a given angle
     	 * @param angle heading
     	 * @param in_radians whether it is radians or degrees
     	 * @return the GPS icon index
     	 */
     	public static int getGpsIconIndexForAngle(double angle, boolean in_radians) {
     		double a_in_degrees = (in_radians) ? (angle * 180.0 / Math.PI) : angle;
     		double step = 360.0 / GPS_CURSOR_ICON_COUNT;
     		if (Math.abs(a_in_degrees) > 1000) {
     			logger.error("Absurd angle: " + angle + "; in_radians = " + in_radians);
     			logger.error("Returned North icon (0)");
     			return 0;
+    		}
     		// normalize
     		while (step >= 360) step = step - 360.0;
     		while (step < 0) step = step + 360.0;
     		int n = Math.round((float) Math.floor(0.5 + a_in_degrees / step));
     		if ((n < 0) || (n >= GPS_CURSOR_ICON_COUNT)) {
     			logger.error("Bad n = " + n + "; GPS_CURSOR_ICON_COUNT = " + GPS_CURSOR_ICON_COUNT);
     			logger.error("Forced n = n MOD GPS_CURSOR_ICON_COUNT");
     			n = n % GPS_CURSOR_ICON_COUNT;
+    		}
     		logger.debug("-------------- GPS icon index for icon: -----------------");
     		logger.debug("angle = " + angle + "; radians = " + in_radians);
     		logger.debug("returned: " + n);
     		return n;
+    	}
     	/**
     	 * Gets an image from the resources folder
     	 * @param dir the resources subfolder
     	 * @param file_name the file name
     	 * @return the image from the resources folder
     	 */
     	public static Image getResourceImage(String dir, String file_name) {
     		String imgPath = resourceDir + File.separator + dir + File.separator + file_name;
     		Image img = Toolkit.getDefaultToolkit().createImage(imgPath);
     		mt.addImage(img,imageCount);
     		try{
     			mt.waitForID(imageCount, IMAGE_LOAD_TIMEOUT);
     			mt.removeImage(img);
     			return img;
     		} catch (InterruptedException e) {
     			logger.error("While downloading: " + e.getMessage());
     			return null;
+    		}
+    	}
     	/**
     	 * Gets an image from an array of bytes for a well known format (png, jpg, gif)
     	 * @param data the byte array
     	 * @return the image
     	 */
     	public static Image getImage(byte[] data) {
     		Image img = Toolkit.getDefaultToolkit().createImage(data);
     		mt.addImage(img,imageCount);
     		try {
     			mt.waitForID(imageCount, IMAGE_LOAD_TIMEOUT);
     			mt.removeImage(img);
     			return img;
     		} catch (InterruptedException e) {
     			logger.error("While downloading: " + e.getMessage());
     			return null;
+    		}
+    	}
     	/**
     	 * Gets scaled version of image with Media Tracker.
+    	 *
     	 * @param img source image
     	 * @param newwidth new width
     	 * @param newheight new height
     	 * @return re sampled image
     	 */
     	public static Image getScaled(Image img, int newwidth, int newheight) {
     		Image newimage = img.getScaledInstance(newwidth, newheight, Image.SCALE_FAST);
     		mt.addImage(newimage, imageCount);
     		try {
     			mt.waitForID(imageCount, IMAGE_LOAD_TIMEOUT);
     			mt.removeImage(newimage);
     			return newimage;
     		} catch (InterruptedException e) {
     			logger.error("While resampling: " + e.getMessage());
     			return null;
+    		}
+    	}
     	/**
     	 * Gets an image from a file in a well known format (png, jpg, gif)
     	 * @param data the image file
     	 * @return the image object
     	 */
     	public static Image getImage(File data) {
     		try {
     			logger.debug("Getting image with Media Tracker: " + data.getAbsolutePath());
     			logger.debug("Getting image with Media Tracker, imagecount = " + imageCount);
     			Image img = Toolkit.getDefaultToolkit().createImage(data.getAbsolutePath());
     			mt.addImage(img, imageCount);
     			mt.waitForID(imageCount, IMAGE_LOAD_TIMEOUT);
     			mt.removeImage(img);
     			return img;
     		} catch (Throwable th) {
     			logger.error("While getting downloaded image: " + th.getMessage());
     			return null;
+    		}
+    	}
     	/**
     	 * gets a file from the working directory
     	 * @param dir subfolder
     	 * @param file_name file name
     	 * @return the file object
     	 */
     	public static File getWorkingDirFile(String dir, String file_name) {
     		File resp = new File(
     				WORKSPACE
     				+ File.separator
     				+ dir
     				+ File.separator
     				+ file_name);
     		return resp;
+    	}
     	/**
     	 * Gets the working subfolder
     	 * @param dir subfolder name
     	 * @return the working subfolder
     	 */
     	public static File getWorkingDir(String dir) {
     		File resp = new File(
     				WORKSPACE
     				+ File.separator
     				+ dir);
     		return resp;
+    	}
     	/**
     	 * Gets a file from the resource folder
     	 * @param dir
     	 * @param file_name
     	 * @return the file object
     	 */
     	public static File getResourceFile(String dir, String file_name) {
     		String filePath = resourceDir + File.separator + dir + File.separator + file_name;
     		File resp = new File(filePath);
     		return resp;
+    	}
     	/**
     	 * Gets a file from the pda sd card folder
     	 * @param dir
     	 * @param file_name
     	 * @return the file object
     	 */
     	public static File getPdaTestFile(String sdfolder, String dir, String file_name) {
     		String filePath = File.separator + sdfolder + File.separator + dir + File.separator + file_name;
     		File resp = new File(filePath);
     		return resp;
+    	}
     	/**
     	 * gets a subfolder from the resources folder
     	 * @param dir the subfolder name
     	 * @return the file object
     	 */
     	public static File getResourceFolder(String dir) {
     		String filePath = resourceDir + File.separator + dir;
     		File resp = new File(filePath);
     		return resp;
+    	}
+    }

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *   Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *   +34 963862235
      *   gvsig@gva.es
      *   http://www.gvsig.gva.es
+     *
      *    or
+     *
      *   Prodevelop Integraci?n de Tecnolog?as SL
      *   Conde Salvatierra de ?lava , 34-10
      *   46004 Valencia
      *   Spain
+     *
      *   +34 963 510 612
      *   +34 963 510 968
      *   gis@prodevelop.es
      *   http://www.prodevelop.es
+     *
      *    or
+     *
      *   Instituto de Rob?tica
      *   Apartado de correos 2085
      *   46071 Valencia
      *   (Spain)
+     *
      *   +34 963 543 577
      *   jjordan@robotica.uv.es
      *   http://robotica.uv.es
+     *
      */
     package org.gvsig.data.datastores.vectorial.file;
     import java.awt.Color;
     import java.awt.Component;
     import java.awt.Font;
     import java.awt.GraphicsConfiguration;
     import java.awt.GraphicsDevice;
     import java.awt.GraphicsEnvironment;
     import java.awt.Image;
     import java.awt.event.MouseEvent;
     import java.awt.geom.AffineTransform;
     import java.awt.geom.Rectangle2D;
     import java.awt.image.BufferedImage;
     import java.io.BufferedReader;
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.FileOutputStream;
     import java.io.FileReader;
     import java.io.IOException;
     import java.io.InputStream;
     import java.text.DecimalFormat;
     import java.text.DecimalFormatSymbols;
     import java.text.ParseException;
     import java.text.SimpleDateFormat;
     import java.util.ArrayList;
     import java.util.Date;
     import org.apache.log4j.Logger;
     /**
      * Utility static methods.
+     *
      * @see es.prodevelop.gvsig.mobile.fmap.util.bytebuffer.FalseByteBuffer
+     *
      * @author jcarras
      * @author jldominguez
+     *
      */
     public class Utils {
     	/**
     	 * Whether the PDA is being used (false when running a PC)
     	 */
     	public static boolean USING_PDA = false;
     	static {
     		if (System.getProperty("os.name").equalsIgnoreCase("WINDOWS CE"))
     			USING_PDA = true;
+    	}
     	/**
     	 * Utility methos to force the execution of the static section
+    	 *
     	 */
     	public static void touch() { }
     	private static Logger logger = Logger.getLogger(Utils.class);
     	public final static String jpeg = "jpeg";
     	public final static String jpg = "jpg";
     	public final static String gif = "gif";
     	public final static String tiff = "tiff";
     	public final static String tif = "tif";
     	public final static String png = "png";
     	public static final String DATE_FORMAT = "yyyy/MM/dd hh:mm";
     	public static final String CACHED_FILES_EXT = ".cac";
     	public static final AffineTransform IDENTITY_AT = AffineTransform
     			.getTranslateInstance(0, 0);
     	public static final Font TILE_PROBLEM_FONT = new Font("Dialog", 3, 12);
     	public static final String TILE_PROBLEM_MSG_403 = "403 Forbidden";
     	public static final String TILE_PROBLEM_MSG_ERROR = "Error";
     	public static final String TILE_PROBLEM_MSG_NODATA = "No data";
     	public static final Color TILE_PROBLEM_403_COLOR = Color.RED;
     	public static final Color TILE_PROBLEM_COLOR = Color.GRAY;
     	public static final int TILE_PROBLEM_X_OFFSET = 10;
     	public static final int TILE_PROBLEM_Y_OFFSET = 21;
     	/**
     	 * Get the extension of a file.
     	 */
     	public static String getExtension(File f) {
     		String ext = null;
     		String s = f.getName();
     		int i = s.lastIndexOf('.');
     		if (i > 0 && i < s.length() - 1) {
     			ext = s.substring(i + 1).toLowerCase();
+    		}
     		return ext;
+    	}
     	/**
     	 * Returns an ImageIcon, or null if the path was invalid.
     	 */
     	protected static Image createImageIcon(String path) {
     		return java.awt.Toolkit.getDefaultToolkit().createImage(path);
     		/*
     		 * java.net.URL imgURL = Utils.class.getResource(path); if (imgURL !=
     		 * null) { return new ImageIcon(imgURL); } else {
     		 * System.err.println("Couldn't find file: " + path); return null; }
     		 */
+    	}
     	/**
     	 * Loads a file into a byte buffer
+    	 *
     	 * @param in input stream
     	 * @param size file size
     	 * @return a byte buffer
     	 * @throws IOException
     	 */
     	public static FalseByteBuffer loadFileInputStream(FileInputStream in,
     			int size) throws IOException {
     		byte[] resp = null;
     		try {
     			resp = getFileBytes(in, size, 10000);
     		} catch (Throwable thr) {
     			logger.error("Did not load file (size = " + size + ")");
     			throw new IOException("Not enough memory (?). Message: "
     					+ thr.getMessage());
+    		}
     		in.close();
     		return new FalseByteBuffer(resp);
+    	}
     	/**
+    	 *
     	 * @return current time as a string
     	 */
     	public static String time() {
     		return System.currentTimeMillis() + " - ";
+    	}
     	private static byte[] getFileBytes(FileInputStream in, int size,
     			int BUFFER_SIZE) throws IOException {
     		int all_bytes_ind = 0;
     		byte[] all_bytes = new byte[size];
     		byte[] buffer = new byte[BUFFER_SIZE];
     		int read;
     		while ((read = in.read(buffer)) != -1) {
     			System.arraycopy(buffer, 0, all_bytes, all_bytes_ind, read);
     			all_bytes_ind = all_bytes_ind + read;
+    		}
     		return all_bytes;
+    	}
     	/**
     	 * Returns whether these rectangles intersect (this was necessary because the original
     	 * metod behaves in a strabge way)
+    	 *
     	 * @param r_1
     	 * @param r_2
     	 * @return whether these rectangles intersect
     	 */
     	public static boolean rectanglesItersect(Rectangle2D r_1, Rectangle2D r_2) {
     		if ((r_1 == null) || (r_2 == null))
     			return false;
     		if (r_1.getMinX() >= r_2.getMaxX())
     			return false;
     		if (r_2.getMinX() >= r_1.getMaxX())
     			return false;
     		if (r_1.getMinY() >= r_2.getMaxY())
     			return false;
     		if (r_2.getMinY() >= r_1.getMaxY())
     			return false;
     		return true;
+    	}
     	private static ArrayList replacePixels(BufferedImage img, int x_offset,
     			int y_offset, int w, int h, ArrayList previous) {
     		ArrayList resp = new ArrayList();
     		int[] new_col = new int[h];
     		int[] new_row = new int[w];
     		for (int i = 0; i < h; i++)
     			new_col[i] = 0;
     		for (int i = 0; i < w; i++)
     			new_row[i] = 0;
     		int[] top_row = img.getRGB(x_offset, y_offset, w, 1, null, 0, w);
     		int[] bottom_row = img.getRGB(x_offset, y_offset + h, w, 1, null, 0, w);
     		int[] right_col = img.getRGB(x_offset + w, y_offset, 1, h, null, 0, 1);
     		int[] left_col = img.getRGB(x_offset, y_offset, 1, h, null, 0, 1);
     		img.setRGB(x_offset, y_offset, w, 1, new_row, 0, w);
     		img.setRGB(x_offset, y_offset + h, w, 1, new_row, 0, w);
     		img.setRGB(x_offset + w, y_offset, 1, h, new_col, 0, 1);
     		img.setRGB(x_offset, y_offset, 1, h, new_col, 0, 1);
     		resp.add(top_row);
     		resp.add(bottom_row);
     		resp.add(right_col);
     		resp.add(left_col);
     		return null;
+    	}
     	private static String getFormattedInteger(int n) {
     		DecimalFormat df = new DecimalFormat();
     		df.setGroupingUsed(true);
     		df.setGroupingSize(3);
     		DecimalFormatSymbols dfs = new DecimalFormatSymbols();
     		dfs.setGroupingSeparator('.');
     		df.setDecimalFormatSymbols(dfs);
     		return df.format(n);
+    	}
     	/**
     	 * Gets a double as a formatted string
+    	 *
     	 * @param d value
     	 * @param decimals number of decimal
     	 * @return the formatted string
     	 */
     	public static String getFormattedDouble(double d, int decimals) {
     		if (false)  return "" + round(d, decimals);
     		// /*
     		DecimalFormat df = new DecimalFormat();
     		df.setGroupingUsed(true);
     		df.setGroupingSize(3);
     		df.setMaximumFractionDigits(decimals);
     		DecimalFormatSymbols dfs = new DecimalFormatSymbols();
     		dfs.setGroupingSeparator(',');
     		dfs.setDecimalSeparator('.');
     		df.setDecimalFormatSymbols(dfs);
     		return df.format(d);
     		// */
+    	}
     	/**
     	 * Gets a scaled version of a given rectangle centered in the same point
+    	 *
     	 * @param r input rectangle
     	 * @param d scale
     	 * @return a scaled version of a given rectangle centered in the same point
     	 */
     	public static Rectangle2D getScaledCenteredRectangle(Rectangle2D r, double d) {
     		double w = r.getWidth() * d;
     		double h = r.getHeight() * d;
     		double x = r.getCenterX() - 0.5 * w;
     		double y = r.getCenterY() - 0.5 * h;
     		Rectangle2D resp = new Rectangle2D.Double(x, y, w, h);
     		return resp;
+    	}
     	/**
     	 * Performs  a product and returns the maximum
+    	 *
     	 */
     	public static int smallerInteger(int a, double f, int minimum) {
     		return Math.max(minimum, (int) Math.round(Math.floor(f * a)));
+    	}
     	public static double smallerDouble(double a, double f, double minimum) {
     		return Math.max(minimum, a * f);
+    	}
     	/**
     	 * Swap objects in a list
     	 * @param _list input list
     	 * @param firstInd index
     	 * @param secondInd index
     	 */
     	public static void swap(ArrayList _list, int firstInd, int secondInd) {
     		Object temp = _list.get(firstInd);
     		_list.set(firstInd, _list.get(secondInd));
     		_list.set(secondInd, temp);
+    	}
     	/**
     	 * Reads the affine transform from a WLD file
     	 * @param imageFile image file
     	 * @param valid_ext valid extensions for WLD files
     	 * @return the affine transform from a WLD file
     	 */
     	public static AffineTransform readWldFile(File imageFile, String[] valid_ext) {
     		String img_file_str = imageFile.getAbsolutePath();
     		int point_ind = img_file_str.lastIndexOf(".");
     		File wldFile = null;
     		String item = "";
     		String new_str = "";
     		for (int i = 0; i < valid_ext.length; i++) {
     			item = valid_ext[i];
     			new_str = img_file_str.substring(0, point_ind) + "." + item;
     			wldFile = new File(new_str);
     			if (wldFile.exists())
     				return readWldFile(wldFile);
+    		}
     		logger.error("World file not found, assumed identity transformation.");
     		return Utils.IDENTITY_AT;
+    	}
     	private static AffineTransform readWldFile(File wf) {
     		AffineTransform resp = Utils.IDENTITY_AT;
     		String item = "";
     		double[] params = new double[6];
     		try {
     			FileReader fr = new FileReader(wf);
     			BufferedReader br = new BufferedReader(fr);
     			for (int i = 0; i < 6; i++) {
     				item = br.readLine();
     				params[i] = Double.parseDouble(item);
+    			}
     			resp.setTransform(params[0], params[1], params[2], params[3],
     					params[4], params[5]);
     		} catch (Exception ex) {
     			logger.error("While opening WLD file: " + ex.getMessage());
+    		}
     		return resp;
+    	}
     //	/**
     //	 * Gets XML text description of booelan value
     //	 *
     //	 * @param name element name
     //	 * @param obj boolean value
     //	 * @return the XML text description of booelan value
     //	 */
     //	public static StringBuffer toXML(String name, boolean obj) {
     //		return toXML(name, new Boolean(obj));
     //	}
     //	/**
     //	 * Gets XML text description of a int value
     //	 *
     //	 * @param name element name
     //	 * @param obj int value
     //	 * @return the XML text description of a int value
     //	 */
     //	public static StringBuffer toXML(String name, int obj) {
     //		return toXML(name, new Integer(obj));
     //	}
     //	/**
     //	 * Gets XML text description of a double value
     //	 *
     //	 * @param name element name
     //	 * @param obj double value
     //	 * @return the XML text description of a double value
     //	 */
     //	public static StringBuffer toXML(String name, double obj) {
     //		return toXML(name, new Double(obj));
     //	}
     	/**
     	 * gets the extent for a given rectangle and affine transform
+    	 *
     	 * @param at teh affinte transform
     	 * @param iw image width
     	 * @param ih image height
     	 * @return the extent in map units
     	 */
     	public static Rectangle2D getExtent(AffineTransform at, int iw, int ih) {
     		double x = at.getTranslateX();
     		double _y = at.getTranslateY();
     		double w = iw * at.getScaleX();
     		double _h = ih * at.getScaleY();
     		double y = Math.min(_y, _y + _h);
     		double h = Math.abs(_h);
     		return new Rectangle2D.Double(x, y, w, h);
+    	}
     	private static GraphicsEnvironment _ge = GraphicsEnvironment
     			.getLocalGraphicsEnvironment();
     	private static GraphicsDevice _dev = _ge.getDefaultScreenDevice();
     	/**
     	 * Device-dependant graphics configuration object
     	 */
     	public static GraphicsConfiguration graphConfig = _dev
     			.getDefaultConfiguration();
     	/**
     	 * Creates a buffered image
     	 * @param w width
     	 * @param h height
     	 * @return a buffered image
     	 */
     	public static BufferedImage createBufferedImage(int w, int h) {
     		return graphConfig.createCompatibleImage(w, h);
+    	}
     	/**
     	 * Creates a buffered image
     	 * @param w width
     	 * @param h height
     	 * @param type the image type
     	 * @return a buffered image
     	 */
     	public static BufferedImage createBufferedImage(int w, int h, int type) {
     		return graphConfig.createCompatibleImage(w, h, type);
+    	}
     	/**
     	 * reads file into byte array
     	 * @param f the file
     	 * @return a byte array with the same data
     	 */
     	public static byte[] readFileIntoByteArray(File f) {
     		byte[] data = null;
     		try {
     			InputStream in = new FileInputStream(f);
     			data = new byte[in.available()];
     			in.read(data);
     		} catch (IOException ex) {
     			logger.error("While reading file " + f.getAbsolutePath() + " : "
     					+ ex.getMessage());
     			data = null;
+    		}
     		return data;
+    	}
     	/**
     	 * @param projectPath
     	 * @param absPath
     	 * @return Path relative to find absPath from projectPath
     	 */
     	public static String relPath(String projectPath, String absPath) {
     		String proj = projectPath;
     		String breadCrumb = "";
     		while (absPath.indexOf(proj) < 0) {
     			int ind = proj.lastIndexOf(File.separator);
     			if (ind < 0)
     				return null; // Imposible to make relative
     			proj = proj.substring(0, ind);
     			breadCrumb += ".." + File.separator;
     			// System.out.println(proj);
+    		}
     		return breadCrumb
     				+ absPath.substring(proj.length() + 1, absPath.length());
+    	}
     	/**
     	 * Finds out the index until which two strings are equal
     	 * @param a
     	 * @param b
     	 * @return the index until which two strings are equal
     	 */
     	public int minCommon(String a, String b) {
     		int i = 0;
     		int min = a.length();
     		if (b.length() < min)
     			min = b.length();
     		while (i < min && a.charAt(i) == b.charAt(i))
     			i++;
     		return i;
+    	}
     	/**
     	 * Writes byte array to file
     	 * @param data
     	 * @param path file path
     	 * @return whether the writing was successful
     	 */
     	public static boolean writeBytesToFile(byte[] data, String path) {
     		try {
     			//createWorkspaceFolder("screenshots");
     			File f = new File(path);
     			if (f.exists())
     				f.delete();
     			FileOutputStream fos = new FileOutputStream(f);
     			fos.write(data);
     			fos.flush();
     			fos.close();
     			return true;
     		} catch (IOException ex) {
     			logger.error("While writing data to file: " + ex.getMessage());
     			return false;
+    		}
+    	}
     	private static void writeCurrentTime(File f, long _t) {
     		try {
     			if (f.exists())
     				f.delete();
     			FileOutputStream fos = new FileOutputStream(f);
     			String t = "" + _t;
     			fos.write(t.getBytes());
     			logger.debug("current time = " + t + " written to file");
     			fos.flush();
     			fos.close();
     		} catch (IOException ex) {
     			logger.error("While writing current time to log file: "
     					+ ex.getMessage());
+    		}
+    	}
     	private static long readLastExeLog(File f) {
     		try {
     			FileReader fr = new FileReader(f);
     			BufferedReader br = new BufferedReader(fr);
     			String item = br.readLine();
     			logger.debug("first line in last exe log file: " + item);
     			return Long.parseLong(item);
     		} catch (Exception ex) {
     			logger.error("While reading last exe log file: " + ex.getMessage());
     			return 0;
+    		}
+    	}
     	/**
     	 * This method finds out if the application is already running. Used to prevent double
     	 * application instantiation
     	 * @param path path of the exe log file
     	 * @param currtime current time in miliseconds
     	 * @return whether the application can be launched
     	 */
     	public static boolean executionAllowed(String path, long currtime) {
     		logger.debug("currtime = " + currtime);
     		File f = new File(path);
     		if (!f.exists()) {
     			logger.debug("last exe log file does not exist...");
     			writeCurrentTime(f, currtime);
     			logger.debug("execution allowed.");
     			return true;
+    		}
     		long last_exe = readLastExeLog(f);
     		if ((currtime - last_exe) > LAST_EXECUTION_INTERVAL) {
     			logger.debug("A long time since last exe.");
     			writeCurrentTime(f, currtime);
     			logger.debug("Execution allowed.");
     			return true;
     		} else {
     			logger.debug("Short time since last exe, execution not allowed.");
     			return false;
+    		}
+    	}
     	/**
     	 * Interval used to check if the application can be launched or not
     	 */
     	public static long LAST_EXECUTION_INTERVAL = 10000;
     	/**
     	 * Gets string representation of a date
     	 * @param date
     	 * @return string representation of a date
     	 */
     	public static String dateToString(Date date){
     		SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
     		String res =format.format(date);
     		return res;
+    	}
     	/**
     	 * Instantiates a Date object from a string
     	 * @param date date as a sring
     	 * @return a Date object
     	 * @throws ParseException
     	 */
     	public static Date dateFromString(String date) throws ParseException{
     		SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
     		Date res = format.parse(date);
     		return res;
+    	}
     	/**
     	 * Rounds a double value keeping the requested decimal positions
     	 * @param val input value
     	 * @param decimals decimal positions requested
     	 * @return rounded value
     	 */
     	private static double round(double val, int decimals){
     		double positions = Math.pow(10 ,decimals);
     		double aux = Math.round((val*positions))/positions;
     		return aux;
+    	}
     	private static String limitString(String str, int n) {
     		int l = str.length();
     		if (l <= n) return str;
     		int head_l = n / 2;
     		int tail_l = n - head_l;
     		return str.substring(0, head_l) + str.substring(l - tail_l, l);
+    	}
     	public static MouseEvent recreateMouseEvent(Component src, int x, int y) {
     		MouseEvent resp = new MouseEvent(src, 0, 0, 0, x, y, 0, false);
     		return resp;
+    	}
+    }

     package org.gvsig.data.datastores.vectorial.file.shp_inst;
     import java.util.ArrayList;
     import java.util.Iterator;
     import org.apache.log4j.Logger;
     import org.gvsig.data.CloseException;
     import org.gvsig.data.DataCollection;
     import org.gvsig.data.DataStoreParameters;
     import org.gvsig.data.InitializeException;
     import org.gvsig.data.OpenException;
     import org.gvsig.data.ReadException;
     import org.gvsig.data.datastores.vectorial.file.shp.SHPStore;
     import org.gvsig.data.vectorial.Feature;
     import org.gvsig.data.vectorial.FeatureType;
     /**
      * This data store creates an array of fully instantiated features when it is opened. Should be by far the fastest
      * and the most memory-consuming
+     *
      * @author jldominguez
+     *
      */
     public class InstSHPStore extends SHPStore {
     	private static Logger logger = Logger.getLogger(InstSHPStore.class);
     	public static String DATASTORE_NAME = "InstSHPStore";
     	static {
     		InstSHPRegister.selfRegister();
+    	}
     	private Feature[] features;
     	private int theSize = 0;
     	public void init(DataStoreParameters p) throws InitializeException {
     		super.init(p);
     		theSize = dbf.getRecordCount();
+    	}
     	public void doOpen() throws OpenException {
     		super.doOpen();
     		// ----------------- get all features: ----------------------
     		features = new Feature[theSize];
     		try {
     			for (int i=0; i<theSize; i++)
     				features[i] = super.getFeatureByPosition(featureType, (long) i);
     		} catch (ReadException ex) {
     			logger.error("While getting all features: " + ex.getMessage());
+    		}
     		logger.debug("Created array in memory with: " + theSize + " features.");
     		// ------------------------
     		try {
     			super.doClose();
     		} catch (CloseException e) {
     			logger.error("While closing after loading: " + e.getMessage());
     			throw new OpenException("hile closing after loading.", e);
+    		}
+    	}
     	protected Feature getFeatureByPosition(FeatureType featureType,
     			long position) throws ReadException {
     		return features[(int) position];
+    	}
     	protected long getFeatureCount() {
     		return theSize;
+    	}
+    }

     package org.gvsig.data.datastores.vectorial.file.shp_inst;
     import org.gvsig.data.DataManager;
     import org.gvsig.data.datastores.vectorial.file.shp.SHPStoreParameters;
     /**
      * Utility class to register the Inst SHP data store.
+     *
      * @see org.gvsig.data.datastores.vectorial.file.shp_inst.InstSHPStore
+     *
      * @author jldominguez
+     *
      */
     public class InstSHPRegister {
     	public static void selfRegister() {
     		DataManager dsm = DataManager.getManager();
     		dsm.registerDataStore(InstSHPStore.DATASTORE_NAME, InstSHPStore.class,
     				SHPStoreParameters.class);
+    	}
+    }

     package org.gvsig.data.datastores.vectorial.file.shp_util;
     import java.awt.geom.Rectangle2D;
     import java.util.List;
     import java.util.Locale;
-...
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.Envelope;
     /**
      * A subclass of AbstractFeature that allows instantiation with data stores other than SHPStore.
+     *
      * @see org.gvsig.data.datastores.vectorial.file.shp.ShpFeature
+     *
      * @author jldominguez
+     *
      */
     public class NewSHPFeature extends AbstractFeature {
     	private static Logger logger = Logger.getLogger(NewSHPFeature.class);
-...
     	private int featureIndex = 0;
     	private IGeometricDataStore store;
     	private Envelope extent = null;
     	/**
+    	 *
     	 * @param ftype feature type
     	 * @param feat_ind feature index
     	 * @param _store the data store to be used
     	 * @throws ReadException
     	 */
     	public NewSHPFeature(
     			FeatureType ftype,
     			int feat_ind,
-...
     	public Envelope getExtent() {
     		// TODO Auto-generated method stub
     		return null;
     		return extent;
+    	}
     	public List getAllSRS() {
-...
     				set(i, value);
     			} catch (Exception ex) {
     				logger.error("While loading feature: " + ex.getMessage());			}
     				logger.error("While loading feature: " + ex.getMessage());
+    			}
+    		}
     		Rectangle2D bb = geometry.getBounds2D();
     		extent = Utils.rectToEnvelope(bb);
     		stopLoading();
+    	}
-...
+    			}
+    		}
     		Rectangle2D bb = geometry.getBounds2D();
     		extent = Utils.rectToEnvelope(bb);
     		stopLoading();
+    	}

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+     *
      * For more information, contact:
+     *
      *   Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
      *   +34 963862235
      *   gvsig@gva.es
      *   http://www.gvsig.gva.es
+     *
      *    or
+     *
      *   Prodevelop Integraci?n de Tecnolog?as SL
      *   Conde Salvatierra de ?lava , 34-10
      *   46004 Valencia
      *   Spain
+     *
      *   +34 963 510 612
      *   +34 963 510 968
      *   gis@prodevelop.es
      *   http://www.prodevelop.es
+     *
      *    or
+     *
      *   Instituto de Rob?tica
      *   Apartado de correos 2085
      *   46071 Valencia
      *   (Spain)
+     *
      *   +34 963 543 577
      *   jjordan@robotica.uv.es
      *   http://robotica.uv.es
+     *
      */
     package org.gvsig.data.datastores.vectorial.file.shp_util;
     import java.awt.Color;
     import java.awt.Component;
     import java.awt.Font;
     import java.awt.GraphicsConfiguration;
     import java.awt.GraphicsDevice;
     import java.awt.GraphicsEnvironment;
     import java.awt.Image;
     import java.awt.event.MouseEvent;
     import java.awt.geom.AffineTransform;
     import java.awt.geom.Rectangle2D;
     import java.awt.image.BufferedImage;
     import java.io.BufferedReader;
     import java.io.File;

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff