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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

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

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 *

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

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

 */

package org.gvsig.tools.dynform.impl;

import java.awt.event.ActionEvent;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JPasswordField;

import javax.swing.JPopupMenu;

import javax.swing.JScrollPane;

import javax.swing.JSpinner;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JToggleButton;

import javax.swing.text.DefaultEditorKit;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.DynFormManager;

import org.gvsig.tools.dynform.JDynForm.DynFormContext;

import org.gvsig.tools.dynform.JDynFormField;

import org.gvsig.tools.dynform.spi.DynFormSPILocator;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynform.spi.dynform.JDynFormFactory;

import org.gvsig.tools.dynform.spi.dynformfield.JCustomSpinner;

import org.gvsig.tools.dynform.spi.dynformfield.JCustomTextArea;

import org.gvsig.tools.dynform.spi.dynformfield.JCustomTextField;

import org.gvsig.tools.dynform.spi.dynformfield.JDynFormFieldFactory;

import org.gvsig.tools.dynform.spi.dynformset.JDynFormSetFactory;

import org.gvsig.tools.dynform.spi.dynformfield.JProblemIndicator;

import org.gvsig.tools.dynform.spi.dynformfield.JZoomDialog;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.service.spi.NotRegisteredException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultDynFormSPIManager implements DynFormSPIManager {

    class DefaultComponentsFactory implements ComponentsFactory {

        private class DefaultScrolledComponent<T> implements ScrolledComponent<T> {

            private final T component;

            private final JScrollPane scrollPane;

            public DefaultScrolledComponent(JScrollPane scrollPane, T component) {

                this.component = component;

                this.scrollPane = scrollPane;

            }

            @Override

            public JScrollPane getScrollPane() {

                return this.scrollPane;

            }

            @Override

            public T getComponent() {

                return this.component;

            }

        }

        @Override

        public boolean containsComponents(DynFormFieldDefinition definition) {

            return false;

        }

        @Override

        public boolean containsJComboBox(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public boolean containsJLabel(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public boolean containsJButton(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public boolean containsJToggleButton(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public boolean containsJSpinner(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public boolean containsJTextField(DynFormFieldDefinition definition, String suffix) {

            return false;

        }

        @Override

        public JCheckBox getJCheckBox(DynFormFieldDefinition definition, String suffix) {

            return new JCheckBox();

        }

        @Override

        public JLabel getJLabel(DynFormFieldDefinition definition, String suffix) {

            return new JLabel();

        }

        @Override

        public JButton getJButton(DynFormFieldDefinition definition, String suffix) {

            return new JButton();

        }

        @Override

        public JToggleButton getJToggleButton(DynFormFieldDefinition definition, String suffix) {

            return new JToggleButton();

        }

        @Override

        public JSpinner getJSpinner(DynFormFieldDefinition definition, String suffix) {

            return new JCustomSpinner(definition.getLabel());

        }

        @Override

        public JComboBox getJComboBox(DynFormFieldDefinition definition, String suffix) {

            return new JComboBox();

        }

        @Override

        public JTextComponent getJTextField(DynFormFieldDefinition definition, String suffix) {

            return new JCustomTextField(definition.getLabel());

        }

        @Override

        public JTextComponent getJPasswordField(DynFormFieldDefinition definition, String suffix) {

            return new JPasswordField(definition.getLabel());

        }

        @Override

        public ScrolledComponent<JTextArea> getJTextArea(DynFormFieldDefinition definition, String suffix) {

            JCustomTextArea component = new JCustomTextArea(definition.getLabel());

            JScrollPane scrollPane = new JScrollPane(component);

            return new DefaultScrolledComponent<>(scrollPane, component);

        }

        @Override

        public ScrolledComponent<JList> getJList(DynFormFieldDefinition definition, String suffix) {

            JList component = new JList();

            JScrollPane scrollPane = new JScrollPane(component);

            return new DefaultScrolledComponent<>(scrollPane, component);

        }

        @Override

        public ScrolledComponent<JTable> getJTable(DynFormFieldDefinition definition, String suffix) {

            JTable component = new JTable();

            JScrollPane scrollPane = new JScrollPane(component);

            return new DefaultScrolledComponent<>(scrollPane, component);

        }

    }

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultDynFormSPIManager.class);

    private DynFormManager manager = null;

    private final Map<String,JDynFormFactory> forms;

    private final Map<String,JDynFormSetFactory> formSets;

    private final List<JDynFormFieldFactory> formFields;

    private final Map<String, PopupMenuActionFactory> popupMenuActions;

    public DefaultDynFormSPIManager() {

        this.forms = new HashMap<>();

        this.formSets = new HashMap<>();

        this.formFields = new ArrayList<>();

        this.popupMenuActions = new HashMap<>();

    }

    @Override

    public ComponentsFactory createDefaultComponentsFactory() {

        return new DefaultComponentsFactory();

    }

    @Override

    public DynFormManager getDynFormManager() {

        if ( manager == null ) {

            manager = DynFormLocator.getDynFormManager();

        }

        return manager;

    }

    @Override

    public JZoomDialog createJZoomDialog(String title, String message, String text) {

        return new DefaultZoomDialog(title, text);

    }

    @Override

    public JProblemIndicator createProblemIndicator(JDynFormField field) {

        return new DefaultJProblemIndicator(field);

    }

    @Override

    @SuppressWarnings("null")

    public JPopupMenu createTextFieldPopupMenu(final String title, final JTextComponent component, boolean zoom) {

        JPopupMenu popupMenu = new JPopupMenu();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

//                JMenuItem textEditorAction = new JMenuItem("Text Editor");

//                textEditorAction.addActionListener(new ActionListener() {

//                        public void actionPerformed(ActionEvent arg0) {

//                                JZoomDialog dialog = DynFormSPILocator.getDynFormSPIManager().createJZoomDialog("Edit the field", null, component.getText());

//                                dialog.setAlwaysOnTop(true);

//                                dialog.setVisible(true);

//                                component.setText(dialog.getText());

//                        }

//                });

        Action textEditorAction = new AbstractAction(i18nManager.getTranslation("text_editor")) {

            @Override

            public void actionPerformed(ActionEvent e) {

                JZoomDialog dialog = DynFormSPILocator.getDynFormSPIManager().createJZoomDialog(title, null, component.getText());

                dialog.setEditable(component.isEditable());

                dialog.setAlwaysOnTop(true);

                dialog.setVisible(true);

                if ( component.isEditable() && component.isEnabled() ) {

                    component.setText(dialog.getText());

                }

            }

        };

        Action copyAction = component.getActionMap().get(DefaultEditorKit.copyAction);

        Action cutAction = component.getActionMap().get(DefaultEditorKit.cutAction);

        Action pasteAction = component.getActionMap().get(DefaultEditorKit.pasteAction);

        Action selectAllAction = component.getActionMap().get(DefaultEditorKit.selectAllAction);

        if ( copyAction == null

                && cutAction == null

                && pasteAction == null

                && selectAllAction == null ) {

            copyAction = component.getActionMap().get( i18nManager.getTranslation("copy"));

            cutAction = component.getActionMap().get( i18nManager.getTranslation("cut"));

            pasteAction = component.getActionMap().get( i18nManager.getTranslation("paste"));

            selectAllAction = component.getActionMap().get( i18nManager.getTranslation("SelectAll"));

        } else {

            copyAction.putValue(Action.NAME, i18nManager.getTranslation("copy"));

            cutAction.putValue(Action.NAME, i18nManager.getTranslation("cut"));

            pasteAction.putValue(Action.NAME, i18nManager.getTranslation("paste"));

            selectAllAction.putValue(Action.NAME, i18nManager.getTranslation("SelectAll"));

        }

        if ( zoom ) {

            popupMenu.add(textEditorAction);

            popupMenu.addSeparator();

        }

        popupMenu.add(cutAction);

        popupMenu.add(copyAction);

        popupMenu.add(pasteAction);

        popupMenu.add(selectAllAction);

        return popupMenu;

    }

    @Override

    public void configurePopupMenu(JDynFormField jfield) {

        for (PopupMenuActionFactory factory : getPopupMenuActionFactories()) {

            if( factory == null ) {

                continue;

            }

            if( factory.isApplicable(jfield) ) {

                jfield.addActionToPopupMenu(factory.getName(), factory.create(jfield));

            }

        }

    }

    @Override

    public Iterable<PopupMenuActionFactory> getPopupMenuActionFactories() {

        return this.popupMenuActions.values();

    }

    @Override

    public void addPopupMenuAction(PopupMenuActionFactory factory) {

        this.popupMenuActions.put(factory.getName(), factory);

    }

    @Override

    public void registerDynFieldFactory(JDynFormFieldFactory factory) {

        this.formFields.add(factory);

        this.formFields.sort(null);

    }

    @Override

    public void registerDynFormFactory(JDynFormFactory factory) {

        this.forms.put(factory.getName(), factory);

    }

    @Override

    public void registerDynFormSetFactory(JDynFormSetFactory factory) {

        this.formSets.put(factory.getName(), factory);

    }

    @Override

    public JDynFormFactory getJDynFormFactory(DynFormContext context, DynFormDefinition definition) throws NotRegisteredException {

        for (JDynFormFactory factory : this.forms.values()) {

            if( factory.isApplicableTo(context, definition) ) {

                return factory;

            }

        }

        throw new NotRegisteredException(definition.getName());

    }

    @Override

    public JDynFormSetFactory getJDynFormSetFactory(DynFormContext context, DynFormDefinition definition, Tags contextTags) throws NotRegisteredException {

        for (JDynFormSetFactory factory : this.formSets.values()) {

            if( factory.isApplicableTo(context, definition, contextTags) ) {

                return factory;

            }

        }

        throw new NotRegisteredException(definition.getName());

    }

    @Override

    public JDynFormFieldFactory getJDynFormFieldFactory(DynFormContext context, DynFormFieldDefinition definition) throws NotRegisteredException {

        for (JDynFormFieldFactory factory : this.formFields) {

            if( factory.isApplicableTo(context, definition) ) {

                return factory;

            }

        }

        LOGGER.warn("Can't get JDynFormFieldFactory for '"+definition.getName()+"'.");

        JDynFormFieldFactory factory = this.getJDynFormFieldFactory("UNKNOWN");

        if( factory==null ) {

            throw new NotRegisteredException(definition.getName());

        }

        return factory;

    }

    @Override

    public JDynFormFieldFactory getJDynFormFieldFactory(String name) {

        for (JDynFormFieldFactory factory : this.formFields) {

            if( StringUtils.equalsIgnoreCase(name, factory.getName()) ) {

                return factory;

            }

        }

        return null;

    }

    @Override

    public List<JDynFormFieldFactory> getJDynFormFieldFactories() {

        return Collections.unmodifiableList(this.formFields);

    }

    public String dumpFactories() {

        StringBuilder builder = new StringBuilder();

        builder.append("JDynForm factories:\n");

        for (JDynFormFactory factory : this.forms.values()) {

            builder.append("- ").append(factory).append("\n");

        }

        builder.append("JDynFormSet factories:\n");

        for (JDynFormSetFactory factory : this.formSets.values()) {

            builder.append("- ").append(factory).append("\n");

        }

        builder.append("JDynFormField factories:\n");

        for (JDynFormFieldFactory factory : this.formFields) {

            builder.append("- ").append(factory).append("\n");

        }

        return builder.toString();

    }

}