Application: gvSIG desktop

  <build>

    <plugins>

      <plugin>

          <!-- Set java compatibility -->

          <groupId>org.apache.maven.plugins</groupId>

          <artifactId>maven-compiler-plugin</artifactId>

          <configuration>

              <source>1.6</source>

              <target>1.6</target>

              <encoding>ISO-8859-1</encoding>

          </configuration>

      </plugin>

      <plugin>

          <groupId>org.codehaus.mojo</groupId>

          <artifactId>animal-sniffer-maven-plugin</artifactId>

          <executions>

              <execution>

                  <id>check-java-api</id>

                  <phase>package</phase>

                  <goals>

                      <goal>check</goal>

                  </goals>

                  <configuration>

                      <skip>false</skip>

                      <signature>

                          <groupId>org.codehaus.mojo.signature</groupId>

                          <artifactId>java16</artifactId>

                          <version>1.0</version>

                      </signature>

                  </configuration>

              </execution>

          </executions>

      </plugin>

    </plugins>

  </build>

        <gvsig.package.info.javaVM>j1_6</gvsig.package.info.javaVM>

import org.gvsig.hyperlink.app.extension.actions.FolderFormat;

        ep.append(FolderFormat.actionCode, "", FolderFormat.class);

package org.gvsig.hyperlink.app.extension.actions;

/*

 * Based on portions of code of MightyPork, http://www.ondrovo.com/

 * extracted from :

 * http://stackoverflow.com/questions/18004150/desktop-api-is-not-supported-on-the-current-platform

 */

import java.awt.Desktop;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DesktopApi {

    private static Logger logger = LoggerFactory.getLogger(DesktopApi.class);

    public static boolean browse(URI uri) {

        if ( browseDESKTOP(uri) ) {

            return true;

        }

        if ( openSystemSpecific(uri.toString()) ) {

            return true;

        }

        return false;

    }

    public static boolean open(File file) {

        if ( openDESKTOP(file) ) {

            return true;

        }

        if ( openSystemSpecific(file.getPath()) ) {

            return true;

        }

        return false;

    }

    public static boolean edit(File file) {

        if ( editDESKTOP(file) ) {

            return true;

        }

        if ( openSystemSpecific(file.getPath()) ) {

            return true;

        }

        return false;

    }

    private static boolean openSystemSpecific(String what) {

        EnumOS os = getOs();

        if ( os.isLinux() ) {

            if ( runCommand("kde-open", "%s", what) ) {

                return true;

            }

            if ( runCommand("gnome-open", "%s", what) ) {

                return true;

            }

            if ( runCommand("xdg-open", "%s", what) ) {

                return true;

            }

        }

        if ( os.isMac() ) {

            if ( runCommand("open", "%s", what) ) {

                return true;

            }

        }

        if ( os.isWindows() ) {

            if ( runCommand("explorer", "%s", what) ) {

                return true;

            }

        }

        return false;

    }

    private static boolean browseDESKTOP(URI uri) {

        logOut("Trying to use Desktop.getDesktop().browse() with " + uri.toString());

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.BROWSE) ) {

                logErr("BORWSE is not supported.");

                return false;

            }

            Desktop.getDesktop().browse(uri);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop browse.", t);

            return false;

        }

    }

    private static boolean openDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().open() with " + file.toString());

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.OPEN) ) {

                logErr("OPEN is not supported.");

                return false;

            }

            Desktop.getDesktop().open(file);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop open.", t);

            return false;

        }

    }

    private static boolean editDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().edit() with " + file);

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.EDIT) ) {

                logErr("EDIT is not supported.");

                return false;

            }

            Desktop.getDesktop().edit(file);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop edit.", t);

            return false;

        }

    }

    private static boolean runCommand(String command, String args, String file) {

        logOut("Trying to exec:\n   cmd = " + command + "\n   args = " + args + "\n   %s = " + file);

        String[] parts = prepareCommand(command, args, file);

        try {

            Process p = Runtime.getRuntime().exec(parts);

            if ( p == null ) {

                return false;

            }

            try {

                int retval = p.exitValue();

                if ( retval == 0 ) {

                    logErr("Process ended immediately.");

                    return false;

                } else {

                    logErr("Process crashed.");

                    return false;

                }

            } catch (IllegalThreadStateException itse) {

                logErr("Process is running.");

                return true;

            }

        } catch (IOException e) {

            logErr("Error running command.", e);

            return false;

        }

    }

    private static String[] prepareCommand(String command, String args, String file) {

        List<String> parts = new ArrayList<String>();

        parts.add(command);

        if ( args != null ) {

            for ( String s : args.split(" ") ) {

                s = String.format(s, file); // put in the filename thing

                parts.add(s.trim());

            }

        }

        return parts.toArray(new String[parts.size()]);

    }

    private static void logErr(String msg, Throwable t) {

        logger.warn(msg,t);

    }

    private static void logErr(String msg) {

        logger.warn(msg);

    }

    private static void logOut(String msg) {

        logger.info(msg);

    }

    public static enum EnumOS {

        linux, macos, solaris, unknown, windows;

        public boolean isLinux() {

            return this == linux || this == solaris;

        }

        public boolean isMac() {

            return this == macos;

        }

        public boolean isWindows() {

            return this == windows;

        }

    }

    public static EnumOS getOs() {

        String s = System.getProperty("os.name").toLowerCase();

        if ( s.contains("win") ) {

            return EnumOS.windows;

        }

        if ( s.contains("mac") ) {

            return EnumOS.macos;

        }

        if ( s.contains("solaris") ) {

            return EnumOS.solaris;

        }

        if ( s.contains("sunos") ) {

            return EnumOS.solaris;

        }

        if ( s.contains("linux") ) {

            return EnumOS.linux;

        }

        if ( s.contains("unix") ) {

            return EnumOS.linux;

        } else {

            return EnumOS.unknown;

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.hyperlink.app.extension.actions;

import java.awt.Desktop;

import java.io.File;

import java.io.IOException;

import java.io.Serializable;

import java.net.URI;

import javax.swing.JOptionPane;

import org.gvsig.andami.PluginServices;

import org.gvsig.hyperlink.app.extension.AbstractActionManager;

import org.gvsig.hyperlink.app.extension.AbstractHyperLinkPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class FolderFormat extends AbstractActionManager implements Serializable {

    /**

     *

     */

    private static final long serialVersionUID = 1L;

    public static final String actionCode = "Folder_format";

    private static Logger logger = LoggerFactory.getLogger(FolderFormat.class);

    public String getActionCode() {

        return actionCode;

    }

    public boolean hasPanel() {

        return false;

    }

    public void showDocument(URI doc) {

        File folder = new File(doc.getPath());

        if ( folder.exists() ) {

               DesktopApi.open(folder);

//             Desktop desktop = Desktop.getDesktop();

//             try {

//                desktop.open(folder);

//            } catch (IOException e1) {

//                logger.error("Can't open folder '" + folder.getAbsolutePath() + "'.", e1);

//            }

        } else {

            JOptionPane.showMessageDialog(null, PluginServices.getText(this, "Bad_path") + " : " + folder.getAbsolutePath());

        }

    }

    public String getDescription() {

        return PluginServices.getText(this, "Shows_Folders_in_gvSIG");

    }

    public String getName() {

        return PluginServices.getText(this, "Folder_formats");

    }

    public AbstractHyperLinkPanel createPanel(URI doc)

            throws UnsupportedOperationException {

        return null;

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 * Copyright (C) 2007-2013 gvSIG Association.

 * as published by the Free Software Foundation; either version 3

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

Shows_Folders_in_gvSIG=Muestra directorios enlazados

Bad_path=La ruta no existe 

Folder_formats=Enlazar con directorios

Bad_path=The path does not exist 

Shows_Folders_in_gvSIG=Shows linked Folders

Folder_formats=Link to Folders