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

org.gvsig.tools.util.impl.ToolsUtilLibraryImpl

package org.gvsig.simplehttpserver;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.net.URLDecoder;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Locale;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.HttpEntity;

import org.apache.http.HttpEntityEnclosingRequest;

import org.apache.http.HttpException;

import org.apache.http.HttpRequest;

import org.apache.http.HttpResponse;

import org.apache.http.HttpStatus;

import org.apache.http.MethodNotSupportedException;

import org.apache.http.NameValuePair;

import org.apache.http.client.utils.URLEncodedUtils;

import org.apache.http.entity.ByteArrayEntity;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.InputStreamEntity;

import org.apache.http.nio.entity.NStringEntity;

import org.apache.http.nio.protocol.BasicAsyncRequestConsumer;

import org.apache.http.nio.protocol.BasicAsyncResponseProducer;

import org.apache.http.nio.protocol.HttpAsyncExchange;

import org.apache.http.nio.protocol.HttpAsyncRequestConsumer;

import org.apache.http.nio.protocol.HttpAsyncRequestHandler;

import org.apache.http.protocol.HttpContext;

import static org.gvsig.simplehttpserver.SimpleServer.INFO;

import static org.gvsig.simplehttpserver.SimpleServer.WARN;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.simplehttpserver.commands.Command;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class HttpHandler implements HttpAsyncRequestHandler<HttpRequest> {

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

    private final SimpleServer server;

    public HttpHandler(SimpleServer server) {

        super();

        this.server = server;

    }

    @Override

    public HttpAsyncRequestConsumer<HttpRequest> processRequest(

            final HttpRequest request,

            final HttpContext context) {

        // Buffer request content in memory for simplicity

        return new BasicAsyncRequestConsumer();

    }

    @Override

    public void handle(

            final HttpRequest request,

            final HttpAsyncExchange httpexchange,

            final HttpContext context) throws HttpException, IOException {

        final HttpResponse response = httpexchange.getResponse();

        handleInternal(request, response, context);

        httpexchange.submitResponse(new BasicAsyncResponseProducer(response));

    }

    private void handleInternal(

            final HttpRequest request,

            final HttpResponse response,

            final HttpContext context) throws HttpException, IOException {

        InputStream contents = null;

        final String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH);

        if (method.equals("GET")) {

            // Do nothing

        } else if (method.equals("POST")) {

            if( request instanceof HttpEntityEnclosingRequest) {

                HttpEntity httpEntity = ((HttpEntityEnclosingRequest)request).getEntity();

                contents = httpEntity.getContent();

            }

        } else {

            this.server.log(WARN, "Method not supported, Only GET/POST supported.");

            throw new MethodNotSupportedException(method + " method not supported");

        }

        String target_uri = request.getRequestLine().getUri();

        String target_path = target_uri;

        List<NameValuePair> queryparams = null;

        try {

            URL url = this.server.getURL(target_path);

            target_path = url.getPath();

            queryparams = URLEncodedUtils.parse(url.getQuery(), Charset.forName("UTF-8"));

        } catch(Exception ex) {

            // Do nothing, ignore exception

        }

        final String commandline = URLDecoder.decode(target_path, "UTF-8");

        final List<String> args = new ArrayList<>();

        args.addAll(Arrays.asList(StringUtils.split(commandline, '/')));

        if( queryparams!=null ) {

            for (NameValuePair queryparam : queryparams) {

                args.add(queryparam.getName());

                args.add(queryparam.getValue());

            }

        }

        final int argc = args.size() - 1;

        Command command = this.server.getCommand(args.get(0));

        if (command == null) {

            this.server.log(WARN, "Command '" + target_uri + "' not found.");

            response.setStatusCode(HttpStatus.SC_NOT_FOUND);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Command " + target_uri

                    + " not found</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if (!command.getNumArgs().contains(argc)) {

            this.server.log(WARN, "Command '" + target_uri + "', invalid number of arguments.");

            response.setStatusCode(HttpStatus.SC_BAD_REQUEST);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Number of arguments invalid in " + target_uri

                    + "</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        Object ret;

        try {

            ret = command.call(argc, args, contents);

        } catch (Exception ex) {

            LOG.warn("Can't server command '" + target_uri + "'.", ex);

            this.server.log(WARN, "Command '" + target_uri + "', error " + ex.getMessage() + ".");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Error processing " + target_uri

                    + "</h1><p>" + ex.toString() + "</p></body></html>",

                    ContentType.create("text/html", "UTF-8")

            );

            response.setEntity(entity);

            return;

        }

        HttpEntity entity;

        response.setStatusCode(HttpStatus.SC_OK);

        if (ret == null) {

            this.server.log(WARN, "Command '" + target_uri + "' return null.");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            entity = new NStringEntity(

                    "<html><body><h1>Process " + target_uri + " return null</h1></body></html>",

                    ContentType.create("text/html", "UTF-8")

            );

        } else if (ret instanceof InputStream) {

            entity = new InputStreamEntity(

                    (InputStream)ret,

                    ContentType.create(command.getMimeType(), "UTF-8")

            );

        } else if (ret instanceof byte[]) {

            entity = new ByteArrayEntity(

                    (byte[]) ret,

                    ContentType.create(command.getMimeType(), "UTF-8")

            );

        } else {

            entity = new NStringEntity(

                    ret.toString(),

                    ContentType.create(command.getMimeType(), "UTF-8")

            );

        }

        response.setEntity(entity);

        this.server.log(INFO, "Command '" + target_uri + "' ok.");

    }

}

package org.gvsig.simplehttpserver;

/**

 *

 * @author gvSIG Team

 */

public class SimpleServerManagerImpl implements SimpleServerManager {

  @Override

  public SimpleServerConfig createSimpleServerConfig() {

    return new SimpleServerConfigImpl();

  }

  @Override

  public SimpleServer createSimpleServer(SimpleServerConfig config) {

    return new SimpleServerImpl(config);

  }

}

package org.gvsig.simplehttpserver;

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.simplehttpserver.commands.Command;

import org.gvsig.simplehttpserver.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) {

        try {

            URL url;

            if( StringUtils.isBlank(path) ) {

                url = new URL("http", "127.0.0.1", this.config.getPort(),"/");

            } else {

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

            }

            return url;

        } catch (MalformedURLException ex) {

            return null;

        }

    }

    @Override

    public String getHost() {

        String host = "http://127.0.0.1:" + 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) {

            log(WARN, "Can't start server ("+ex.getMessage()+").");

        }

    }

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

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.simplehttpserver.commands.CommandFactory;

import org.gvsig.simplehttpserver.commands.HelpFactory;

import org.gvsig.tools.util.PropertiesSupportHelper;

/**

 *

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

  private final PropertiesSupportHelper propertiesHelper = new PropertiesSupportHelper();

  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;

  }

  @Override

  public SimpleServerConfig setTimeout(int timeout) {

    int oldValue = this.timeout;

    this.timeout = timeout;

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

    return this;

  }

  @Override

  public String getServerInfo() {

    return this.serverInfo;

  }

  @Override

  public SimpleServerConfig setServerInfo(String serverInfo) {

    String oldValue = this.serverInfo;

    this.serverInfo = serverInfo;

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

    return this;

  }

  @Override

  public void addPropertyChangeListener(PropertyChangeListener listener) {

    this.propertyChangeSupport.addPropertyChangeListener(listener);

  }

  @Override

  public void removePropertyChangeListener(PropertyChangeListener listener) {

    this.propertyChangeSupport.removePropertyChangeListener(listener);

  }

  @Override

  public Collection<CommandFactory> getCommandFactories() {

    return this.commandFactories.values();

  }

  @Override

  public SimpleServerConfig addCommandFactory(CommandFactory factory) {

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

    return this;

  }

  @Override

  public void removeCommandFactory(CommandFactory factory) {

    this.commandFactories.remove(factory.getName());

  }

  @Override

  public void removeCommandFactory(String name) {

    this.commandFactories.remove(name);

  }

    @Override

    public Object getProperty(String name) {

        return this.propertiesHelper.getProperty(name);

    }

    @Override

    public void setProperty(String name, Object value) {

        this.propertiesHelper.setProperty(name, value);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesHelper.getProperties();

    }

}

/**

 * 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.euclidean.DefaultEuclideanManager;

import org.gvsig.filedialogchooser.impl.DefaultFileDialogChooserManager;

import org.gvsig.imageviewer.DefaultImageViewerManager;

import org.gvsig.json.JsonManagerImpl;

import org.gvsig.propertypage.impl.DefaultPropertiesPageManager;

import org.gvsig.simplehttpserver.SimpleServerManagerImpl;

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;

import org.gvsig.webbrowser.cssbox.CSSBoxWebBrowserManager;

import org.gvsig.webbrowser.impl.DefaultWebBrowserManager;

import org.gvsig.webbrowser.impl.DefaultWebBrowserPanel;

/**

 * {@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);

        ToolsUtilLocator.registerDefaultWebBrowserManager(DefaultWebBrowserManager.class);

        ToolsUtilLocator.registerWebBrowserManager(CSSBoxWebBrowserManager.class);

        ToolsUtilLocator.registerEuclideanManager(DefaultEuclideanManager.class);

        ToolsUtilLocator.registerJsonManager(JsonManagerImpl.class);

        ToolsUtilLocator.registerSimpleServerManager(SimpleServerManagerImpl.class);

        DefaultWebBrowserPanel.selfRegister();

    }

    @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.awt.event.ActionEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collection;

import javax.swing.AbstractAction;

import javax.swing.AbstractButton;

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JMenuItem;

import javax.swing.JPopupMenu;

import org.apache.commons.collections4.CollectionUtils;

import org.gvsig.configurableactions.ConfigurableActionsMamager.ActionsController;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.SupportIsEnable;

import org.gvsig.tools.swing.api.SupportIsVisible;

public class ActionsControllerImpl implements ActionsController {

    private final JComponent component;

    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 ActionsControllerImpl(Collection<Action> actions, Object source, JComponent component)  {

        this.component = component;

        this.source = source;

        this.update(actions);

        this.initComponent();

    }

    private void initComponent() {

        I18nManager i18n = ToolsLocator.getI18nManager();

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

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

        if( component instanceof AbstractButton ) {

            AbstractButton comp = (AbstractButton) this.component;

            if( comp.getText().equals("...") ) {

                comp.setText("");

            }

            comp.setIcon(new ImageIcon(url));

        } else if( component instanceof JLabel ) {

            JLabel comp = (JLabel) this.component;

            if( comp.getText().equals("...") ) {

                comp.setText("");

            }

            comp.setIcon(new ImageIcon(url));

        }

        this.component.setBorder(null);

        this.component.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();

//            }

//        });

    }

    @Override

    public void update(Collection<Action> actions) {

        this.actions = actions;

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

            this.component.setVisible(false);

        } else {

            this.component.setVisible(true);

        }

    }

    @Override

    public Collection<Action> getActions() {

        return this.actions;

    }

    @Override

    public JComponent getComponent() {

        return component;

    }

    @Override

    public Object getSource() {

        return source;

    }

    @Override

    public void addAction(Action action) {

        Collection<Action> theActions = new ArrayList<>();

        if( CollectionUtils.isNotEmpty(this.actions) ) {

            theActions.addAll(this.actions);

        }

        theActions.add(action);

        this.actions = theActions;

    }

    private void doShowMenu() {

        JPopupMenu menu = new JPopupMenu();

        SupportIsVisible visible = null;

        if( this.source instanceof SupportIsVisible ) {

            visible = (SupportIsVisible) this.source;

        }

        SupportIsEnable enabled = null;

        if( this.source instanceof SupportIsEnable ) {

            enabled = (SupportIsEnable) this.source;

        }

        for (Action action : actions) {

            if( visible==null || visible.isVisible(action) ) {

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

                if( enabled!=null && !enabled.isEnabled(action)) {

                    item.setEnabled(false);

                }

                menu.add(item);

            }

        }

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

    }

}

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 javax.swing.JLabel;

import org.apache.commons.lang3.StringUtils;

public class DefaultConfigurableActionsMamager implements ConfigurableActionsMamager {

    private class PanelActions {

        List<Action> actions;

        WeakReference<ActionsControllerImpl> controller;

        private final String panelid;

        public PanelActions(String panelid) {

           this.panelid = panelid;

           this.actions = new ArrayList<>();

        }

        public void setController(ActionsControllerImpl controller) {

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

        }

        public ActionsControllerImpl getController() {

            if( this.controller == null ) {

                return null;

            }

            ActionsControllerImpl theController = this.controller.get();

            return theController;

        }

        public void updateComponent() {

            ActionsControllerImpl theController = this.getController();

            if( theController == null ) {

                return;

            }

            theController.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 final 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);

        }

        JComponent component = new JLabel();

        ActionsControllerImpl controller = new ActionsControllerImpl(panelActions.getActions(), source, component);

        panelActions.setController(controller);

        return component;

    }

    @Override

    public ActionsController getConfigurableActionsController(String panelid) {

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

        if( panelActions==null ) {

            return null;

        }

        return panelActions.getController();

    }

    @Override

    public void addConfigurableActions(String panelid, Object source, JComponent component) {

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

        if( panelActions==null ) {

            panelActions = new PanelActions(panelid);

            this.panelsActions.put(panelid, panelActions);

        }

        ActionsControllerImpl controller = new ActionsControllerImpl(panelActions.getActions(), source, component);

        panelActions.setController(controller);

    }

}

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) {