Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.vectorediting.swing.impl.contextmenu;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.util.List;

import java.util.Map;

import javax.swing.AbstractAction;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JSeparator;

import javax.swing.SwingConstants;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.RunnableWithParameters;

import org.gvsig.vectorediting.lib.api.EditingService;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;

import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;

import org.gvsig.vectorediting.swing.api.EditingContext;

import org.gvsig.vectorediting.swing.api.contextmenu.AcceptValueListener;

import org.gvsig.vectorediting.swing.api.contextmenu.EditingContextMenu;

/**

 * @author llmarques

 *

 */

public class DefaultEditingContextMenu extends EditingContextMenuView implements

EditingContextMenu {

    private static Logger LOGGER = LoggerFactory

        .getLogger(DefaultEditingContextMenu.class);

    private static final long serialVersionUID = -3207749321400180897L;

    private AcceptValueListener listener;

    private Component parent;

    private EditingServiceParameter parameter;

    private EditingContext context;

    /**

     * @param parent

     * @param listener

     * @param parameter

     */

    public DefaultEditingContextMenu(Component parent,

        AcceptValueListener listener, EditingServiceParameter parameter) {

        this(parent, listener, parameter, null);

    }

    /**

     * @param parent

     * @param listener

     * @param parameter

     * @param context

     */

    public DefaultEditingContextMenu(Component parent,

        AcceptValueListener listener, EditingServiceParameter parameter, EditingContext context) {

        super();

        this.listener = listener;

        this.parent = parent;

        this.parameter = parameter;

        this.context = context;

        initActions();

    }

    @SuppressWarnings("serial")

    private void initActions() {

        EditingService service = context.getActiveService();

        List<EditingServiceParameter> parameters = service.getParameters();

        for (EditingServiceParameter param : parameters) {

            if(param.equals(this.parameter)){

                continue;

            }

            if(param.isOptional() && service.isEnabled(param)){

                initAction(param, new AcceptValueListener() {

                    @Override

                    public void acceptValue(Object value) {

                        try {

                            context.setValue(param, (String)value);

                        } catch (InvalidEntryException ex) {

                            LOGGER.warn("Invalid value", ex);

                        }

                    }

                });

            }

        }

        initAction(parameter, this.listener);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        AbstractAction action = null;

        this.add(new JSeparator(SwingConstants.HORIZONTAL));

        action = new AbstractAction(i18nManager.getTranslation("cancel")) {

            public void actionPerformed(ActionEvent e) {

                listener.acceptValue(null);

            }

        };

        this.add(action);

        ((JComponent) parent).add(this);

    }

    private void initAction(EditingServiceParameter param, AcceptValueListener listener){

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        AbstractAction action = null;

        for (final TYPE type : param.getTypes()) {

            switch (type) {

            case OPTION:

                Map<String, String> options = param.getOptions();

                for (String key : options.keySet()) {

                    String value = i18nManager.getTranslation(options.get(key));

                    action = new AbstractAction(value) {

                        public void actionPerformed(ActionEvent e) {

                            String key = (String) this.getValue("key");

                            listener.acceptValue(key);

                        }

                    };

                    action.putValue("key", key);

                    this.add(action);

                }

                break;

            case VALUE:

                String name =

                i18nManager.getTranslation(param.getName()) + " ("

                    + i18nManager.getTranslation("value") + ")";

                action = new AbstractAction(name) {

                    public void actionPerformed(ActionEvent e) {

                        String value = showValueDialog(param);

                        if (StringUtils.isNotEmpty(value)) {

                            listener.acceptValue(value);

                        }

                    }

                };

                this.add(action);

                break;

            case POSITION:

            case LIST_POSITIONS:

                name =

                i18nManager.getTranslation(param.getName()) + " ("

                    + i18nManager.getTranslation("point") + ")";

                action = new AbstractAction(name) {

                    public void actionPerformed(ActionEvent e) {

                        String value = showPointDialog(param);

                        if (value != null) {

                            listener.acceptValue(value);

                        }

                    }

                };

                this.add(action);

                break;

            case SELECTION:

            case GEOMETRY:

                break;

            }

        }

    }

    /**

     * @return this as JComponent

     */

    public JComponent asJComponent() {

        return this;

    }

    private String showPointDialog(EditingServiceParameter parameter) {

        int dimension = 2;

        Object defaultValue = parameter.getDefaultValue();

        Point defaultPoint = null;

        if (defaultValue != null && defaultValue instanceof Point) {

            defaultPoint = (Point)defaultValue;

            dimension = defaultPoint.getDimension();

        }

        final DefaultDynamicEditingPointPanel pointPanel = new DefaultDynamicEditingPointPanel(null, defaultPoint);

        if(defaultPoint!=null){

            for(int i=0; i<dimension; i++){

                pointPanel.setValue(i, String.valueOf(defaultPoint.getCoordinateAt(i)));

            }

        }

        final String title = ToolsLocator.getI18nManager().getTranslation(parameter.getName());

        RunnableWithParameters runnable = new RunnableWithParameters() {

            public void run() {

                this.returnValue =

                    JOptionPane.showConfirmDialog(null, pointPanel, title, JOptionPane.OK_CANCEL_OPTION);

            }

        };

        if (SwingUtilities.isEventDispatchThread()) {

            runnable.run();

        } else {

            try {

                SwingUtilities.invokeAndWait(runnable);

            } catch (Exception e) {

                LOGGER.info("Can't show point dialog.", e);

            }

        }

            int result = ((Integer) runnable.getReturnValue());

            if (result == JOptionPane.OK_OPTION) {

                StringBuilder stb = new StringBuilder();

                for(int i=0; i<dimension; i++){

                    String value = pointPanel.getValue(i);

                    stb.append(value);

                    if(i<dimension-1){

                        stb.append(",");

                    }

                }

                return stb.toString();

            }

            return null;

    }

    private String showValueDialog(EditingServiceParameter parameter) {

        final DefaultEditingValuePanel valuePanel =

            new DefaultEditingValuePanel();

        final String title =

            ToolsLocator.getI18nManager().getTranslation(parameter.getName());

        RunnableWithParameters runnable = new RunnableWithParameters() {

            public void run() {

                this.returnValue =

                    JOptionPane.showConfirmDialog(null, valuePanel, title,

                        JOptionPane.OK_CANCEL_OPTION);

            }

        };

        if (SwingUtilities.isEventDispatchThread()) {

            runnable.run();

        } else {

            try {

                SwingUtilities.invokeAndWait(runnable);

            } catch (Exception e) {

                LOGGER.info("Can't show value dialog.", e);

            }

        }

        int result = ((Integer) runnable.getReturnValue());

        if (result == JOptionPane.OK_OPTION) {

            return valuePanel.getValue();

        }

        return null;

    }

}