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

org.gvsig.tools.util.impl.ToolsUtilLibraryImpl

/**

 * 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 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., 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.tools.util.impl;

import org.gvsig.configurableactions.DefaultConfigurableActionsMamager;

import org.gvsig.filedialogchooser.impl.DefaultFileDialogChooserManager;

import org.gvsig.imageviewer.DefaultImageViewerManager;

import org.gvsig.propertypage.impl.DefaultPropertiesPageManager;

import org.gvsig.svgsupport.DumbSVGSupportManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.util.ToolsUtilLibrary;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 * {@link Library} for the default tools util implementation.

 *

 * @author gvSIG team

 */

public class ToolsUtilLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        super.doRegistration();

        registerAsImplementationOf(ToolsUtilLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        ToolsUtilLocator.registerDefaultToolsUtilManager(DefaultToolsUtilManager.class);

        ToolsUtilLocator.registerDefaultFileDialogChooserManager(DefaultFileDialogChooserManager.class);

        ToolsUtilLocator.registerDefaultSVGSupportManager(DumbSVGSupportManager.class);

        ToolsUtilLocator.registerDefaultImageViewerManager(DefaultImageViewerManager.class);

        ToolsUtilLocator.registerDefaultConfigurableActionsMamager(DefaultConfigurableActionsMamager.class);

        ToolsUtilLocator.registerDefaultPropertiesPageManager(DefaultPropertiesPageManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

    }

}

package org.gvsig.tools.util.impl;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringEscapeUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.util.InformationBuilder;

public class BaseInformationBuilder implements InformationBuilder {

    private String backgroundColor = "\"#FFFFFF\"";

    private String backgroundColorTitle = "\"#FBFFE1\""; // light yellow

    private String backgroundColorPropertyLabel = "\"#D6D6D6\""; // Gris

    private String backgroundColorPropertyValue1 = "\"#FEEDD6\""; // light salmon

    private String backgroundColorPropertyValue2 = "\"#EAEAEA\""; // light grey

    protected int propertyCount = 0;

    protected final List<Element> elements;

    protected class BaseTitleElement implements TitleElement {

        protected String label;

        @Override

        public TitleElement value(String format, Object... args) {

            if (args == null) {

                this.label = format;

            } else {

                this.label = String.format(format, args);

            }

            return this;

        }

        @Override

        public TitleElement label(String label) {

            this.label = StringEscapeUtils.escapeHtml3(label);

            return this;

        }

        @Override

        public TitleElement labelkey(String labelkey) {

            return label(ToolsLocator.getI18nManager().getTranslation(labelkey));

        }

        @Override

        public String build() {

            propertyCount = 0;

            return "<tr valign=\"middle\" >"

                    + "<td bgcolor=" + backgroundColorTitle + " align=\"center\" colspan=\"2\"><font face=\"Arial\" size=\"3\"><b> " + this.label + "</b></font></td>"

                    + "</tr>";

        }

    }

    protected class BaseRawElement implements RawElement {

        protected String value;

        @Override

        public RawElement value(String format, Object... args) {

            if (args == null) {

                this.value = format;

            } else {

                this.value = String.format(format, args);

            }

            return this;

        }

        @Override

        public String build() {

            String color = ((propertyCount++ % 2) == 0) ? backgroundColorPropertyValue1 : backgroundColorPropertyValue2;

            String content = "<tr valign=\"top\">\n";

            content += "<td bgcolor=" + color + "align=\"left\" colspan=\"2\"><font face=\"Arial\" size=\"3\"><div>" + value.replace("\\n",  "<br>\n") + "</div></font></td>\n";

            content += "</tr>\n";

            return content;

        }

    }

    protected class BaseTextElement implements TextElement {

        protected String value;

        @Override

        public TextElement value(String format, Object... args) {

            if (args == null) {

                this.value = StringEscapeUtils.escapeHtml3(format);

            } else {

                this.value = StringEscapeUtils.escapeHtml3(String.format(format, args));

            }

            return this;

        }

        @Override

        public String build() {

            String color = ((propertyCount++ % 2) == 0) ? backgroundColorPropertyValue1 : backgroundColorPropertyValue2;

            String content = "<tr valign=\"top\">\n";

            content += "<td bgcolor=" + color + "align=\"left\" colspan=\"2\"><font face=\"Arial\" size=\"3\">" + value.replace("\n",  "<br>\n") + "</font></td>\n";

            content += "</tr>\n";

            return content;

        }

    }

    protected class BasePropertyElement implements PropertyElement {

        protected String label;

        protected boolean monospace = false;

        protected String value;

        @Override

        public PropertyElement value(String format, Object... args) {

            if (args == null) {

                this.value = StringEscapeUtils.escapeHtml3(format);

            } else {

                this.value = StringEscapeUtils.escapeHtml3(String.format(format, args));

            }

            return this;

        }

        @Override

        public PropertyElement label(String label) {

            this.label = StringEscapeUtils.escapeHtml3(label);

            return this;

        }

        @Override

        public PropertyElement labelkey(String labelkey) {

            return label(ToolsLocator.getI18nManager().getTranslation(labelkey));

        }

        @Override

        public PropertyElement monospace() {

            this.monospace = true;

            return this;

        }

        @Override

        public String build() {

            String color = ((propertyCount++ % 2) == 0) ? backgroundColorPropertyValue1 : backgroundColorPropertyValue2;

            String content = "<tr valign=\"top\">\n";

            if (!StringUtils.isEmpty(label)) {

                content += "<td nowrap bgcolor=" + backgroundColorPropertyLabel + "align=\"right\" width=\"140\"><font face=\"Arial\" size=\"3\">" + label + ":&nbsp;</font></td>\n";

            }

            if( this.monospace ) {

                content += "<td bgcolor=" + color + "align=\"left\"><font face=\"Monospaced\" size=\"3\">" + value.replace("\\n",  "<br>\n") + "</font></td>";

            } else {

                content += "<td bgcolor=" + color + "align=\"left\"><font face=\"Arial\" size=\"3\">" + value.replace("\\n",  "<br>\n") + "</font></td>";

            }

            content += "</tr>\n";

            return content;

        }

    }

    public BaseInformationBuilder() {

        this.elements = new ArrayList<>();

    }

    @Override

    public InformationBuilder backgroundColor(String color) {

        this.backgroundColor = color;

        return this;

    }

    @Override

    public InformationBuilder backgroundColorTitle(String color) {

        this.backgroundColorTitle = color;

        return this;

    }

    @Override

    public InformationBuilder backgroundColorPropertyLabel(String color) {

        this.backgroundColorPropertyLabel = color;

        return this;

    }

    @Override

    public InformationBuilder backgroundColorPropertyValue1(String color) {

        this.backgroundColorPropertyValue1 = color;

        return this;

    }

    @Override

    public InformationBuilder backgroundColorPropertyValue2(String color) {

        this.backgroundColorPropertyValue2 = color;

        return this;

    }

    @Override

    public TitleElement title() {

        TitleElement element = new BaseTitleElement();

        this.elements.add(element);

        return element;

    }

    @Override

    public PropertyElement property() {

        PropertyElement element = new BasePropertyElement();

        this.elements.add(element);

        return element;

    }

    @Override

    public TextElement text() {

        TextElement element = new BaseTextElement();

        this.elements.add(element);

        return element;

    }

    @Override

    public RawElement raw() {

        RawElement element = new BaseRawElement();

        this.elements.add(element);

        return element;

    }

    @Override

    public String build() {

        StringBuilder html = new StringBuilder();

        html.append("<html>\n");

        html.append("<body bgcolor=").append(backgroundColor).append(" topmargin=\"0\" marginheight=\"0\">\n");

        html.append("<table cellpadding=\"0\" cellspacing=\"0\" align=\"center\" width=\"100%\">");

        boolean first = true;

        for (Element element : elements) {

            if( element instanceof TitleElement ) {

                if( first ) {

                    first = false;

                } else {

                    html.append("<tr>\n<td><br></td>\n<td></td></tr>\n");

                }

            }

            html.append(element.build());

        }

        html.append("</table>");

        html.append("</body>");

        html.append("</html>");

        return html.toString();

    }

    @Override

    public String toString() {

        return this.build();

    }

}

package org.gvsig.tools.util.impl;

import org.gvsig.desktopopen.DefaultDesktopOpen;

import org.gvsig.desktopopen.DesktopOpen;

import org.gvsig.htmlbuilder.HTMLBuilder;

import org.gvsig.htmlbuilder.impl.DefaultHTMLBuilder;

import org.gvsig.tools.util.InformationBuilder;

import org.gvsig.tools.util.ToolsUtilManager;

/**

 * @author fdiaz

 *

 */

public class DefaultToolsUtilManager implements ToolsUtilManager {

    @Override

    public InformationBuilder createInformationBuilder() {

        return new BaseInformationBuilder();

    }

    @Override

    public DesktopOpen createDesktopOpen() {

        return new DefaultDesktopOpen();

    }

    public HTMLBuilder createHTMLBuilder() {

        DefaultHTMLBuilder x = new DefaultHTMLBuilder();

        return x;

    }

}

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.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

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.apache.commons.lang3.StringUtils;

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 = createPage(factory, 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;

                }

                return StringUtils.compareIgnoreCase(f1.getTitle(), f2.getTitle());

            }

        });

        return pages;

    }

    private PropertiesPage createPage(PropertiesPageFactory factory, Object container, Object data) 

        throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException 

        {

        PropertiesPage page;

        try {

            page = factory.create(container, data);

            return page;

        } catch(AbstractMethodError ex) {

        }

        // Antes factory.create llevaba solo un argumento, data. Probamos 

        // invocando a ese create.

        Method method = factory.getClass().getMethod("create", Object.class);

        page = (PropertiesPage) method.invoke(factory, data);

        return page;

    }

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

public class DefaultImageViewerManager implements ImageViewerManager {

    @Override

    public ImageViewer createImageViewer() {

        return new DefaultImageViewer();

    }

}

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.simplehttpservice;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.ExceptionLogger;

import org.apache.http.impl.nio.bootstrap.HttpServer;

import org.apache.http.impl.nio.bootstrap.ServerBootstrap;

import org.apache.http.impl.nio.reactor.IOReactorConfig;

import org.gvsig.simplehttpservice.commands.Command;

import org.gvsig.simplehttpservice.commands.CommandFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class SimpleServerImpl implements SimpleServer {

    private static final Logger LOG = LoggerFactory.getLogger(SimpleServerImpl.class);

    private static final List<HttpServer> SERVERS = new ArrayList<>();

    static {

        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override

            public void run() {

                for (HttpServer server : SERVERS) {

                    server.shutdown(5, TimeUnit.SECONDS);

                }

            }

        });

    }

    private HttpServer server;

    private final Set<LoggerListener> loglisteners;

    private Map<String, Command> commands;

    private final SimpleServerConfig config;

    public SimpleServerImpl(SimpleServerConfig config) {

        this.config = config;

        this.loglisteners = new HashSet<>();

    }

    @Override

    public Map<String, Command> getCommands() {

        if (this.commands == null) {

            Map<String, Command>theCommands = new LinkedHashMap<>();

            for (CommandFactory factory : this.config.getCommandFactories()) {

                theCommands.put(factory.getName(), factory.create(this));

            }

            this.commands = theCommands;

        }

        return this.commands;

    }

    @Override

    public Command getCommand(String commandName) {

        if (commandName == null) {

            return null;

        }

        Command command = this.getCommands().get(commandName.toLowerCase());

        return command;

    }

    @Override

    public SimpleServerConfig getConfig() {

        return this.config;

    }

    @Override

    public void addLogListener(LoggerListener logger) {

        this.loglisteners.add(logger);

    }

    @Override

    public void removeLogListener(LoggerListener logger) {

        this.loglisteners.remove(logger);

    }

    @Override

    public URL getURL(String path) {

        if( StringUtils.isBlank(path) ) {

            return null;

        }

        try {

            URL url = new URL("http", "localhost", this.config.getPort(),path);

            return url;

        } catch (MalformedURLException ex) {

            return null;

        }

    }

    @Override

    public String getHost() {

        String host = "http://localhost:" + this.config.getPort();

        return host;

    }

    @Override

    public void log(int level, String message) {

        switch (level) {

            default:

            case INFO:

                LOG.info(message);

                break;

            case WARN:

                LOG.warn(message);

                break;

            case DEBUG:

                LOG.debug(message);

                break;

        }

        for (LoggerListener logger : loglisteners) {

            logger.log(level, message);

        }

    }

    @Override

    public synchronized void start() {

        if (this.server != null) {

            this.stop();

        }

        final IOReactorConfig theConfig = IOReactorConfig.custom()

                .setSoTimeout(this.config.getTimeout())

                .setTcpNoDelay(true)

                .build();

        this.server = ServerBootstrap.bootstrap()

                .setListenerPort(this.config.getPort())

                .setServerInfo(this.config.getServerInfo())

                .setIOReactorConfig(theConfig)

                .setExceptionLogger(ExceptionLogger.STD_ERR)

                .registerHandler("*", new HttpHandler(this))

                .create();

        try {

            this.server.start();

            //this.server.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);

            SERVERS.add(this.server);

            log(INFO, "Server started.");

        } catch (Exception ex) {

        }

    }

    @Override

    public void reload() {

    }

    @Override

    public synchronized boolean isStarted() {

        return this.server != null;

    }

    @Override

    @SuppressWarnings("SleepWhileHoldingLock")

    public synchronized void stop() {

        if (this.server == null) {

            log(INFO, "Server already stoped.");

            return;

        }

        this.server.shutdown(5, TimeUnit.SECONDS);

        try {

            Thread.sleep(6000);

        } catch (InterruptedException ex) {

        }

        SERVERS.remove(this.server);

        this.server = null;

        log(INFO, "Server stoped.");

    }

}

package org.gvsig.simplehttpservice;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.simplehttpservice.commands.CommandFactory;

import org.gvsig.simplehttpservice.commands.HelpFactory;

/**

 *

 * @author jjdelcerro

 */

public class SimpleServerConfigImpl implements SimpleServerConfig {

  private int port;

  private int timeout;

  private String serverInfo;

  private boolean autostart;

  private final PropertyChangeSupport propertyChangeSupport;

  private final Map<String, CommandFactory> commandFactories;

  public SimpleServerConfigImpl() {

    this.port = 9876;

    this.timeout = 15000;

    this.serverInfo = "Test/1.1";

    this.propertyChangeSupport = new PropertyChangeSupport(this);

    this.commandFactories = new HashMap<>();

    HelpFactory factory = new HelpFactory();

    this.commandFactories.put(factory.getName().toLowerCase(), factory);

  }

  @Override

  public int getPort() {

    return this.port;

  }

  @Override

  public SimpleServerConfig setPort(int port) {

    int oldValue = this.port;

    this.port = port;

    this.propertyChangeSupport.firePropertyChange("port", oldValue, port);

    return this;

  }

  @Override

  public int getTimeout() {

    return this.timeout;

  }