Application: gvSIG desktop

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

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;

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

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

/**

 * 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;

        }

        public static Envelope rectToEnvelope(Rectangle2D bb) {

                if (bb == null) return null;

                double[] min = new double[2];

                double[] max = new double[2];

                min[0] = bb.getMinX();

                min[1] = bb.getMinY();

                max[0] = bb.getMaxX();

                max[1] = bb.getMaxY();

                return new DefaultEnvelope(2, min, max);

        }

}