Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.configurableactions;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.Action;

import javax.swing.JComponent;

import org.apache.commons.lang3.StringUtils;

public class DefaultConfigurableActionsMamager implements ConfigurableActionsMamager {

    private class PanelActions {

        List<Action> actions;

        WeakReference<ActionsComponent> component;

        private final String panelid;

        public PanelActions(String panelid) {

           this.panelid = panelid;

           this.actions = new ArrayList<>();

        }

        public void setComponent(ActionsComponent component) {

            this.component = new WeakReference<>(component);

        }

        public ActionsComponent getComponent() {

            if( this.component == null ) {

                return null;

            }

            ActionsComponent component = this.component.get();

            return component;

        }

        public void updateComponent() {

            ActionsComponent component = this.getComponent();

            if( component == null ) {

                return;

            }

            component.update(actions);

        }

        public int size() {

            return this.actions.size();

        }

        public Action get(int i) {

            return this.actions.get(i);

        }

        public void set(int i, Action action) {

            this.actions.set(i, action);

            this.updateComponent();

        }

        public void add(Action action) {

            this.actions.add(action);

            this.updateComponent();

        }

        public void remove(int i) {

            this.actions.remove(i);

            this.updateComponent();

        }

        public Collection<Action> getActions() {

            return this.actions;

        }

        private void removeAll() {

            this.actions.clear();

            this.updateComponent();

        }

    }

    private Map<String,PanelActions> panelsActions;

    public DefaultConfigurableActionsMamager() {

        this.panelsActions = new HashMap<>();

    }

    @Override

    public void addConfigurableAction(String panelid, Action action) {

        PanelActions panelActions = this.panelsActions.get(panelid);

        if( panelActions==null ) {

            panelActions = new PanelActions(panelid);

            this.panelsActions.put(panelid, panelActions);

        }

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

            Action currentAction = panelActions.get(i);

            if( StringUtils.equalsIgnoreCase(

                    (String)currentAction.getValue(Action.ACTION_COMMAND_KEY), 

                    (String)action.getValue(Action.ACTION_COMMAND_KEY) ) ) {

                    panelActions.set(i, action);

                    return;

            }

        }

        panelActions.add(action);

    }

    @Override

    public void removeConfigurableAction(String panelid, String actionName) {

        PanelActions panelActions = this.panelsActions.get(panelid);

        if( panelActions==null ) {

            return;

        }

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

            Action currentAction = panelActions.get(i);

            if( StringUtils.equalsIgnoreCase(

                    (String)currentAction.getValue(Action.ACTION_COMMAND_KEY), 

                    actionName ) ) {

                    panelActions.remove(i);

                    return;

            }

        }

    }

    @Override

    public void removeAllConfigurableActions(String panelid) {

        PanelActions panelActions = this.panelsActions.get(panelid);

        if( panelActions==null ) {

            return;

        }

        panelActions.removeAll();

    }

    @Override

    public Collection<Action> getConfigurableActions(String panelid) {

        PanelActions panelActions = this.panelsActions.get(panelid);

        if( panelActions==null ) {

            panelActions = new PanelActions(panelid);

            this.panelsActions.put(panelid, panelActions);

        }

        return panelActions.getActions();

    }

    @Override

    public JComponent getConfigurableActionsComponent(String panelid, Object source) {

        PanelActions panelActions = this.panelsActions.get(panelid);

        if( panelActions==null ) {

            panelActions = new PanelActions(panelid);

            this.panelsActions.put(panelid, panelActions);

        }

        ActionsComponent component = new ActionsComponent(panelActions.getActions(), source);

        panelActions.setComponent(component);

        return component;

    }

}

package org.gvsig.configurableactions;

import java.awt.event.ActionEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.Collection;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JLabel;

import javax.swing.JMenuItem;

import javax.swing.JPopupMenu;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

public class ActionsComponent extends JLabel {

    private final Object source;

    private Collection<Action> actions;

    private class ActionListenerAdapter extends AbstractAction {

        private final Action action;

        public ActionListenerAdapter(Action action) {

            this.action = action;

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            e.setSource(source);

            action.actionPerformed(e);

        }

        @Override

        public Object getValue(String key) {

            return action.getValue(key);

        }

        @Override

        public void putValue(String key, Object newValue) {

            action.putValue(key, newValue);

        }

        @Override

        public boolean isEnabled() {

            return action.isEnabled(); 

        }

        @Override

        public void setEnabled(boolean newValue) {

            action.setEnabled(newValue); 

        }

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public ActionsComponent(Collection<Action> actions, Object source)  {

        this.source = source;

        this.update(actions);

        this.initComponent();

    }

    private void initComponent() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.setToolTipText(i18n.getTranslation("_Click_to_see_more_action_in_this_panel"));

        URL url = this.getClass().getResource("/org/gvsig/configurableactions/images/configurableactions.png");

        this.setIcon(new ImageIcon(url));

        this.setBorder(null);

        this.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if( e.getClickCount()==1 && e.getButton()==MouseEvent.BUTTON1 ) {

                    doShowMenu();

                }

            }

        });

//        this.addActionListener(new ActionListener() {

//            @Override

//            public void actionPerformed(ActionEvent e) {

//                doShowMenu();

//            }

//        });

    }

    public void update(Collection<Action> actions) {

        this.actions = actions;

        if( actions==null || actions.isEmpty() ) {

            this.setVisible(false);

        } else {

            this.setVisible(true);

        }

    }

    private void doShowMenu() {

        JPopupMenu menu = new JPopupMenu();

        for (Action action : actions) {

            JMenuItem item = new JMenuItem(new ActionListenerAdapter(action));

            menu.add(item);

        }

        menu.show(this, 0,this.getHeight());

    }

}

package org.gvsig.propertypage.impl;

import java.awt.event.ActionEvent;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.propertypage.PropertiesPage;

import org.gvsig.propertypage.PropertiesPage.SetPageEnabledEvent;

import org.gvsig.propertypage.PropertiesPageFactory;

import org.gvsig.propertypage.PropertiesPageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.identitymanagement.SimpleIdentity;

import org.gvsig.tools.identitymanagement.SimpleIdentityManager;

import org.gvsig.tools.util.Invocable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultPropertiesPageManager implements PropertiesPageManager {

    private static class DefaultSetPageEnabledEvent extends ActionEvent {

        private Invocable filter;

        private boolean enabled;

        public DefaultSetPageEnabledEvent(Object source, Invocable filter, boolean enabled ) {

            super(source, SetPageEnabledEvent.ID, SetPageEnabledEvent.ACTION_COMMAND);

            this.filter = filter;

            this.enabled = enabled;

        }

        public Invocable getFilter() {

            return filter;

        }

        public boolean isEnabled() {

            return enabled;

        }

    }

    public static final String ACCESS_PAGE_AUTHORIZATION = "propertypage-access";

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

    private final Map<String, Map<String, PropertiesPageFactory>> groups = new HashMap<>();

    public DefaultPropertiesPageManager() {

    }

    private String getFactoryName(PropertiesPageFactory factory) {

        String factoryName = factory.getClass().getName();

        try {

            factoryName = factory.getName();

        } catch(Throwable ex) {

        }

        return factoryName;

    }

    @Override

    public void registerFactory(PropertiesPageFactory factory) {

        logger.info("Register PropertisPageFactory " + factory.getClass().getName() + " , groupID=" + factory.getGroupID() + " (" + factory.toString() + ").");

        Map<String, PropertiesPageFactory> group = this.getFactories(factory.getGroupID());

        group.put(getFactoryName(factory), factory);

    }

    private Map<String, PropertiesPageFactory> getFactories(String groupID) {

        logger.info("get propeties page factories for groupID '" + groupID + "'");

        Map<String,PropertiesPageFactory> group = this.groups.get(groupID);

        if (group == null) {

            group = new HashMap<>();

            this.groups.put(groupID, group);

        }

        return group;

    }

    @Override

    public List<PropertiesPage> getPages(String groupID, Object container, Object data) {

        logger.info("get propeties page for groupID '" + groupID + "', and object '" + ((data==null)?"null":data.toString()) + "'.");

        List<PropertiesPage> pages = new ArrayList<>();

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        SimpleIdentity currentUser = identityManager.getCurrentIdentity();

        if (!currentUser.isAuthorized(ACCESS_PAGE_AUTHORIZATION,null,groupID ) ) {

            return pages; // Empty list, no access to pages authoriced

        }

        Collection<PropertiesPageFactory> factories = this.getFactories(groupID).values();

        String authorizationId = ACCESS_PAGE_AUTHORIZATION+"-"+groupID;

        for (PropertiesPageFactory factory : factories) {

            String factoryName = getFactoryName(factory);

            try {

                if (factory.isVisible(data)) {

                    PropertiesPage page = factory.create(container, data);

                    if (currentUser.isAuthorized(authorizationId,page, page.getTitle()) ) {

                        pages.add(page);

                    }

                }

            } catch(Throwable ex) {

                logger.warn("Can't get properties page from factory '"+factoryName+"'.",ex);

            }

        }

        Collections.sort(pages, new Comparator<PropertiesPage>() {

            @Override

            public int compare(PropertiesPage f1, PropertiesPage f2) {

                int n = f2.getPriority() - f1.getPriority();

                if (n != 0) {

                    return n;

                }

                if (f1.getTitle() == null || f2.getTitle() == null) {

                    // Mas que nada para que no pete, y aunque el orden

                    // no sea correcto muestre algo al usuario.

                    return 0;

                }

                return f1.getTitle().compareTo(f2.getTitle());

            }

        });

        return pages;

    }

    @Override

    public ActionEvent createSetPageEnableEvent(PropertiesPage source, Invocable filter, boolean enabled) {

        return new DefaultSetPageEnabledEvent(source, filter, enabled);

    }

    @Override

    public ActionEvent createSetPageEnableEvent(final PropertiesPage source, final Class filterClass, final boolean enabled) {

        return new DefaultSetPageEnabledEvent(

                source, 

                new Invocable() {

                    @Override

                    public Object call(Object... propertiesPages) {

                        return filterClass.isInstance(propertiesPages[0]);

                    }

                }, 

                enabled

        );

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.filedialogchooser.impl;

import com.googlecode.vfsjfilechooser2.VFSJFileChooser;

import com.googlecode.vfsjfilechooser2.filechooser.AbstractVFSFileFilter;

import java.awt.Component;

import java.beans.PropertyChangeListener;

import java.io.File;

import javax.swing.JComponent;

import javax.swing.filechooser.FileFilter;

import org.apache.commons.vfs2.FileObject;

import org.apache.commons.vfs2.provider.local.LocalFile;

import org.gvsig.filedialogchooser.FileDialogChooser;

import org.gvsig.filedialogchooser.FileDialogChooserManager;

import org.gvsig.tools.util.ToolsUtilLocator;

public class VFSJFileChooserBased implements FileDialogChooser {

    private static class FileFilterAdapter extends AbstractVFSFileFilter {

        private final FileFilter filter;

        FileFilterAdapter(FileFilter filter) {

            this.filter = filter;

        }

        @Override

        public boolean accept(FileObject f) {

            if( f instanceof LocalFile ) {

                return this.filter.accept( new File(f.getName().getPath()));

            }

            return false;

        }

        @Override

        public String getDescription() {

            return this.filter.getDescription();

        }

        public FileFilter getFilter() {

            return this.filter;

        }

    }

    private final VFSJFileChooser jfc;

    private final String fileChooserID;

    public VFSJFileChooserBased(String fileChooserID) {

        super();

        this.jfc = new VFSJFileChooser();

        this.fileChooserID = fileChooserID;

    }

    @Override

    public void setCurrentDirectory(File dir) {

        if( dir == null ) {

            dir = new File(System.getProperty("user.home"));

        }

        this.jfc.setCurrentDirectory(dir);

    }

    @Override

    public File getCurrentDirectory() {

        return this.jfc.getCurrentDirectory();

    }

    @Override

    public void setDialogTitle(String dialogTitle) {

        this.jfc.setDialogTitle(dialogTitle);

    }

    @Override

    public void setDialogType(int dialogType) {

        switch(dialogType) {

        default:

        case OPEN_DIALOG:

            this.jfc.setDialogType(VFSJFileChooser.DIALOG_TYPE.OPEN);

            break;

        case SAVE_DIALOG:

            this.jfc.setDialogType(VFSJFileChooser.DIALOG_TYPE.SAVE);

            break;

        }

    }

    @Override

    public void setDragEnabled(boolean b) {

        this.jfc.setDragEnabled(b);

    }

    @Override

    public void setFileFilter(FileFilter filter) {

        if( filter == null ) {

            this.jfc.setFileFilter(null);

        } else {

            this.jfc.setFileFilter(new FileFilterAdapter(filter));

        }

    }

    @Override

    public FileFilter getFileFilter() {

        FileFilterAdapter f = (FileFilterAdapter) this.jfc.getFileFilter();

        return f.getFilter();

    }

    @Override

    public void setFileSelectionMode(int mode) {

        switch(mode) {

        case FILES_ONLY:

            this.jfc.setFileSelectionMode(VFSJFileChooser.SELECTION_MODE.FILES_ONLY);

            break;

        case DIRECTORIES_ONLY:

            this.jfc.setFileSelectionMode(VFSJFileChooser.SELECTION_MODE.DIRECTORIES_ONLY);

            break;

        default:

        case FILES_AND_DIRECTORIES:

            this.jfc.setFileSelectionMode(VFSJFileChooser.SELECTION_MODE.FILES_AND_DIRECTORIES);

            break;

        }

    }

    @Override

    public File getSelectedFile() {

        return this.jfc.getSelectedFile();

    }

    @Override

    public File[] getSelectedFiles() {

        return this.jfc.getSelectedFiles();

    }

    @Override

    public void setFileHidingEnabled(boolean b) {

        this.jfc.setFileHidingEnabled(b);

    }

    @Override

    public void setMultiSelectionEnabled(boolean b) {

        this.jfc.setMultiSelectionEnabled(b);

    }

    @Override

    public boolean isMultiSelectionEnabled() {

        return this.jfc.isMultiSelectionEnabled();

    }

    @Override

    public int showOpenDialog(Component parent) {

        FileDialogChooserManager manager = ToolsUtilLocator.getFileDialogChooserManager();

        File f = this.getCurrentDirectory();

        if( f==null ) {

            f = manager.getLastPath(fileChooserID, null);

            this.jfc.setCurrentDirectory(f);

        }        

        VFSJFileChooser.RETURN_TYPE r = this.jfc.showOpenDialog(parent);

        if( r == VFSJFileChooser.RETURN_TYPE.CANCEL ) {

            return CANCEL_OPTION;            

        }

        if( r == VFSJFileChooser.RETURN_TYPE.APPROVE ) {

            manager.setLastPath(fileChooserID, this.getCurrentDirectory());

            return APPROVE_OPTION;            

        }

        if( r == VFSJFileChooser.RETURN_TYPE.ERROR ) {

            return ERROR_OPTION;            

        }

        return ERROR_OPTION;            

    }

    @Override

    public int showSaveDialog(Component parent) {

        FileDialogChooserManager manager = ToolsUtilLocator.getFileDialogChooserManager();

        File f = manager.getLastPath(fileChooserID, this.getCurrentDirectory());

        this.jfc.setCurrentDirectory(f);

        VFSJFileChooser.RETURN_TYPE r = this.jfc.showSaveDialog(parent);

        if( r == VFSJFileChooser.RETURN_TYPE.CANCEL ) {

            return CANCEL_OPTION;            

        }

        if( r == VFSJFileChooser.RETURN_TYPE.APPROVE ) {

            manager.setLastPath(fileChooserID, this.getCurrentDirectory());

            return APPROVE_OPTION;            

        }

        if( r == VFSJFileChooser.RETURN_TYPE.ERROR ) {

            return ERROR_OPTION;            

        }

        return ERROR_OPTION;            

    }

    @Override

    public void setAcceptAllFileFilterUsed(boolean b) {

        this.jfc.setAcceptAllFileFilterUsed(b);

    }

    @Override

    public void addChoosableFileFilter(FileFilter next) {

        this.jfc.addChoosableFileFilter(new FileFilterAdapter(next));

    }

    @Override

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.jfc.addPropertyChangeListener(listener);

    }

    @Override

    public void setAccessory(JComponent newAccessory) {

        this.jfc.setAccessory(newAccessory);

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.filedialogchooser.impl;

import java.awt.Component;

import java.awt.HeadlessException;

import java.io.File;

import javax.swing.JFileChooser;

import org.gvsig.filedialogchooser.FileDialogChooser;

import org.gvsig.filedialogchooser.FileDialogChooserManager;

import org.gvsig.tools.util.ToolsUtilLocator;

public class JFileChooserBased extends JFileChooser implements FileDialogChooser {

    private static final long serialVersionUID = 2825200958209418322L;

    private final String fileChooserID;

    public JFileChooserBased(String fileChooserID) {

        super();

        this.fileChooserID = fileChooserID;

    }

    @Override

    public int showOpenDialog(Component parent) throws HeadlessException {

        FileDialogChooserManager manager = ToolsUtilLocator.getFileDialogChooserManager();

        File f = this.getCurrentDirectory();

        if( f==null ) {

            f = manager.getLastPath(fileChooserID, null);

            super.setCurrentDirectory(f);

        }

        int r = super.showOpenDialog(parent);

        if( r == JFileChooser.APPROVE_OPTION ) {

            manager.setLastPath(fileChooserID, this.getCurrentDirectory());

        }

        return r;

    }

    @Override

    public int showSaveDialog(Component parent) throws HeadlessException {

        FileDialogChooserManager manager = ToolsUtilLocator.getFileDialogChooserManager();

        File f = manager.getLastPath(fileChooserID, this.getCurrentDirectory());

        super.setCurrentDirectory(f);        int r = super.showSaveDialog(parent);

        if( r == JFileChooser.APPROVE_OPTION ) {

            manager.setLastPath(fileChooserID, this.getCurrentDirectory());

        }

        return r;

    }    

}

package org.gvsig.filedialogchooser.impl;

import java.io.File;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.filedialogchooser.FileDialogChooser;

import org.gvsig.filedialogchooser.FileDialogChooserManager;

import org.gvsig.tools.ToolsLocator;

public class DefaultFileDialogChooserManager implements FileDialogChooserManager {

    private Map<String,File> lastPaths;

    private boolean useNativeFileChooser = true;

    public DefaultFileDialogChooserManager() {

        this.lastPaths = new HashMap<>();

    }

    @Override

    public void setUseNativeFileChooser(boolean b) {

        useNativeFileChooser = b;

    }

    @Override

    public boolean useNativeFileChooser() {

        return useNativeFileChooser;

    }

    @Override

    public FileDialogChooser create(String fileChooserID) {

        if( useNativeFileChooser ) {

          return new JFileChooserBased(fileChooserID);

        }

        return new VFSJFileChooserBased(fileChooserID);

    }

    @Override

    public FileDialogChooser create() {

        String fileChooserID = "DEFAULT_ID";

        if( useNativeFileChooser ) {

            return new JFileChooserBased(fileChooserID);

        }

        return new VFSJFileChooserBased(fileChooserID);

    }

    @Override

    public File getLastPath(String fileChooserID, File defaultDirectory) {

        return ToolsLocator.getFoldersManager().getLastPath(fileChooserID, defaultDirectory);

    }

    @Override

    public void setLastPath(String fileChooserID, File path) {

        ToolsLocator.getFoldersManager().setLastPath(fileChooserID, path);

    }

}

package org.gvsig.imageviewer;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Image;

import java.io.File;

import java.net.URL;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JPanel;

@SuppressWarnings("UseSpecificCatch")

public class DefaultImageViewer extends JPanel implements ImageViewer {

    private JLabel label;

    public DefaultImageViewer() {

        this.initComponents();

    }

    private void initComponents() {

        this.label = new JLabel();

        this.setLayout(new BorderLayout());

        this.add(this.label, BorderLayout.CENTER);

        this.setPreferredSize( new Dimension(200,350));

    }

    private void setImage(ImageIcon image) {

        this.label.setIcon(image);

        this.setPreferredSize(new Dimension(image.getIconWidth(), image.getIconHeight()));

    }

    @Override

    public void setImage(URL image) {

        ImageIcon img = new ImageIcon(image);

        this.setImage(img);

    }

    @Override

    public void setImage(File image) {

        try {

            this.setImage(image.toURI().toURL());

        } catch(Exception ex) {

            throw new IllegalArgumentException(ex);

        }

    }

    @Override

    public void setImage(Image image) {

        ImageIcon img = new ImageIcon(image);

        this.setImage(img);

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public void clean() {

        this.label.setIcon(null);

    }

}

package org.gvsig.imageviewer;

public class DefaultImageViewerManager implements ImageViewerManager {

    @Override

    public ImageViewer createImageViewer() {

        return new DefaultImageViewer();

    }

}

package org.gvsig.desktopopen;

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;

/*

 * 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

 */

public class DefaultDesktopOpen implements DesktopOpen {

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

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

        }

    }

    @Override

    public boolean browse(URI uri) {

        if ( browseDESKTOP(uri) ) {

            return true;

        }

        return openSystemSpecific(uri.toString());

    }

    @Override

    public boolean open(File file) {

        if ( openDESKTOP(file) ) {

            return true;

        }

        return openSystemSpecific(file.getPath());

    }

    @Override

    public boolean edit(File file) {

        if ( editDESKTOP(file) ) {

            return true;

        }

        return openSystemSpecific(file.getPath());

    }

    private boolean openSystemSpecific(String what) {

        EnumOS os = getOs();

        if (os.isLinux()) {

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

//                return true;

//            }

//            if (runCommand("kde-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 boolean browseDESKTOP(URI uri) {

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

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logger.warn("Platform is not supported.");

                return false;

            }

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

                logger.warn("BROWSE is not supported.");

                return false;

            }

            Desktop.getDesktop().browse(uri);

            return true;

        } catch (Throwable t) {

            if( logger.isDebugEnabled() ) {

                logger.warn("Error using desktop browse.", t);

            } else {

                logger.warn("Error using Desktop.getDesktop().browse(). "+ t.toString());

            }

            return false;

        }

    }

    private boolean openDESKTOP(File file) {

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

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logger.warn("Platform is not supported.");

                return false;

            }

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

                logger.warn("OPEN is not supported.");

                return false;

            }

            Desktop.getDesktop().open(file);

            return true;

        } catch (Throwable t) {

            if( logger.isDebugEnabled() ) {

                logger.warn("Error using desktop open.", t);

            } else {

                logger.warn("Error using Desktop.getDesktop().open(). "+ t.toString());

            }

            return false;

        }

    }

    private boolean editDESKTOP(File file) {

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

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logger.warn("Platform is not supported.");

                return false;

            }

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

                logger.warn("EDIT is not supported.");

                return false;

            }

            Desktop.getDesktop().edit(file);

            return true;

        } catch (Throwable t) {

            if( logger.isDebugEnabled() ) {

                logger.warn("Error using desktop edit.", t);

            } else {

                logger.warn("Error using Desktop.getDesktop().edit(). "+ t.toString());

            }

            return false;

        }

    }

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

        logger.info("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 ) {

                    logger.warn("Process ended immediately.");

                    return false;

                } else {

                    logger.warn("Process crashed.");

                    return false;

                }

            } catch (IllegalThreadStateException itse) {

                logger.warn("Process is running.");

                return true;

            }

        } catch (IOException e) {

            if( logger.isDebugEnabled() ) {

                logger.warn("Error running command.", e);

            } else {

                logger.warn("Error running command. "+ e.toString());

            }

            return false;

        }

    }

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

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

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

    }

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

        }

    }

}

package org.gvsig.htmlbuilder.impl;

import java.awt.Color;

import java.util.ArrayList;

import java.util.Date;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringEscapeUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.htmlbuilder.HTMLBuilder;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLColor;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLComplexElement;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLElement;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLElementWithAttributes;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLElementWithContents;

/**

 *

 * @author jjdelcerro

 */

public class DefaultHTMLBuilder implements HTMLBuilder {

    public class CustomHTMLElement implements HTMLElement {

        private final String text;

        CustomHTMLElement(String text) {

            this.text = text;

        }

        @Override

        public boolean allowContents() {

            return false;

        }

        @Override

        public boolean allowAttributes() {

            return false;

        }

        @Override

        public String toHTML() {

            return this.text;

        }

        @Override

        public String toString() {

            return this.toHTML();

        }

    }

    public class ContentsHTMLElement implements HTMLElementWithContents {

        private final List<HTMLElement>contents;

        public ContentsHTMLElement() {

            this.contents = new ArrayList<>();

        }

        @Override

        public boolean allowContents() {

            return true;

        }

        @Override

        public boolean allowAttributes() {

            return false;

        }

        @Override

        public String toHTML() {

            StringBuilder builder = new StringBuilder();

            for (HTMLElement content : this.contents) {

                builder.append(content.toHTML());

            }

            return builder.toString();

        }

        @Override

        public String toString() {

            return this.toHTML();

        }

        @Override

        public HTMLElementWithContents contents(Object... values) {

            if( values == null ) {

                return this;

            }

            for (Object value : values) {

                if( value == null ) {

                    continue;

                }

                if( value instanceof HTMLElement ) {

                    this.contents.add((HTMLElement) value);

                } else {

                    this.contents.add(custom(value.toString()));

                }

            }

            return this;

        }

        @Override

        public List<HTMLElement> getContents() {

            return this.contents;

        }

    }

    public class DefaultHTMLElement implements HTMLComplexElement {

        private final String name;

        private final boolean allowContents;

        private final boolean allowAttributes;

        private Map<String,String> attributes;

        private Map<String,String> style;        

        private ContentsHTMLElement contents;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public DefaultHTMLElement(String name, 

                boolean allowContents, 

                boolean allowAttributes, 

                Object... contents

            ) {

            this.name = name;

            this.allowAttributes = allowAttributes;

            this.allowContents = allowContents;

            this.attributes = null;

            this.contents = null;

            if( this.allowContents ) {

                this.contents(contents);

            }

        }

        @Override

        public Map<String,String> getAttributes() {

            if( this.attributes==null ) {

                this.attributes = new LinkedHashMap<>();

            }

            return this.attributes;

        }

        @Override

        public Map<String,String> getStyle() {

            if( this.style==null ) {

                this.style = new LinkedHashMap<>();

            }

            return this.style;

        }

        @Override

        public List<HTMLElement> getContents() {

            if( this.contents==null ) {

                this.contents = new ContentsHTMLElement();

            }

            return this.contents.getContents();

        }

        @Override

        public HTMLComplexElement set(String name, String value) {

            if( !this.allowAttributes()) {

                throw new RuntimeException("The element '"+this.name+"' don't allow attributes.");

            }

            this.getAttributes().put(name, value);

            return this;

        }

        @Override

        public HTMLComplexElement set(String name) {

            return set(name, (String)null);

        }

        @Override

        public HTMLComplexElement set(String name, int value) {

            return set(name, String.valueOf(value));

        }

        @Override

        public HTMLComplexElement set(String name, double value) {

            return set(name, String.valueOf(value));

        }

        @Override

        public HTMLComplexElement set(String name, HTMLColor value) {

            return set(name, value.toHTML());

        }

        @Override

        public HTMLComplexElement style(String name, String value) {

            if( !this.allowAttributes()) {

                throw new RuntimeException("The element '"+this.name+"' don't allow attributes.");

            }

            this.getStyle().put(name, value);

            return this;

        }

        @Override

        public HTMLComplexElement style(String name, int value) {

            return style(name, String.valueOf(value));

        }

        @Override

        public HTMLComplexElement style(String name, double value) {

            return style(name, String.valueOf(value));

        }

        @Override

        public HTMLComplexElement style(String name, HTMLColor value) {

            return style(name, value.toHTML());

        }

        @Override

        public HTMLComplexElement contents(Object... values) {

            if( values == null ) {

                return this;

            }

            if( !this.allowContents() ) {

                throw new RuntimeException("The element '"+this.name+"' don't allow contents.");

            }

            for (Object value : values) {

                if( value == null ) {

                    continue;

                }

                if( value instanceof HTMLElement ) {

                    this.getContents().add((HTMLElement) value);

                } else {

                    this.getContents().add(custom(value.toString()));

                }

            }

            return this;

        }

        @Override

        public boolean allowContents() {

            return this.allowContents;

        }

        @Override

        public boolean allowAttributes() {

            return this.allowAttributes;

        }

        @Override

        public String toHTML() {

            StringBuilder builder = new StringBuilder();

            builder.append("<");

            builder.append(this.name);

            if( this.attributes!=null ) {

                for (Map.Entry<String, String> entry : this.attributes.entrySet()) {

                    builder.append(" ");

                    builder.append(entry.getKey());

                    if( entry.getValue()!=null ) {

                        builder.append("=\"");

                        builder.append(StringEscapeUtils.escapeHtml4(entry.getValue()));

                        builder.append("\"");

                    }

                }

            }

            if( this.style!=null ) {

                builder.append(" style=\"");

                for (Map.Entry<String, String> entry : this.style.entrySet()) {

                    builder.append(entry.getKey());

                    builder.append(":");

                    builder.append(StringEscapeUtils.escapeHtml4(entry.getValue()));

                    builder.append(" ");

                }

                builder.append("\"");

            }

            if( this.contents!=null ) {

                builder.append(">\n");

                builder.append(this.contents.toHTML());

                builder.append("</");

                builder.append(this.name);

                builder.append(">\n");

            } else {

                builder.append("/>\n");

            }

            return builder.toString();

        }

        @Override

        public String toString() {

            return this.toHTML();

        }

    }

    public class DefaultHTMLColor implements HTMLColor {

        private String color = "white";

        public DefaultHTMLColor(String color) {

            this.color = color;

        }

        public DefaultHTMLColor(int r, int g, int b) {

            this("rgb("+r+","+g+","+b+")");

        }

        public DefaultHTMLColor(Color color) {

            this(color.getRed(), color.getGreen(), color.getBlue());

        }

        @Override

        public boolean allowContents() {

            return false;

        }

        @Override

        public boolean allowAttributes() {

            return false;

        }

        @Override

        public String toHTML() {

            return this.color;

        }

        @Override

        public String toString() {

            return this.color;

        }

    }

    @Override

    public HTMLElement custom(String value) {

        return new CustomHTMLElement(value);

    }

    @Override

    public HTMLElement plain(String value) {

        return new CustomHTMLElement(StringEscapeUtils.escapeHtml4(value));

    }

    @Override

    public HTMLElement plainWithNl(String value) {

        return new CustomHTMLElement(StringEscapeUtils.escapeHtml4(value).replace("\n", "<br>\n"));

    }

    @Override

    public HTMLElement contents(HTMLElement... values) {

        return new ContentsHTMLElement().contents((Object[]) values);

    }

    @Override

    public HTMLColor color(Color color) {

        return new DefaultHTMLColor(color);

    }

    @Override

    public HTMLColor color(int r, int g, int b) {

        return new DefaultHTMLColor(r, g, b);

    }

    @Override

    public HTMLColor color(String color) {

        return new DefaultHTMLColor(color);

    }

    @Override

    public HTMLComplexElement  a(String link, Object... contents) {

        return new DefaultHTMLElement("a", true, true, contents);

    }

    @Override

    public HTMLComplexElement  a(Object... contents) {

        return new DefaultHTMLElement("a", true, true, contents);

    }

    @Override

    public HTMLComplexElement  abbr(Object... contents) {

        return new DefaultHTMLElement("abbr", true, true, contents);