Application: gvSIG desktop

package org.gvsig.expressionevaluator.swing.impl;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.net.URL;

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 java.util.function.Predicate;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.text.JTextComponent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.swing.CalculatorController;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.JExpressionBuilder;

import org.gvsig.expressionevaluator.swing.Element;

import org.gvsig.expressionevaluator.swing.Element.ConstantElement;

import org.gvsig.expressionevaluator.swing.Element.FunctionElement;

import org.gvsig.expressionevaluator.swing.Element.GroupElement;

import org.gvsig.expressionevaluator.swing.ElementFactory;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.expressionevaluator.swing.FunctionAdditionalPanelFactory;

import org.gvsig.expressionevaluator.swing.JExpressionPicker;

import org.gvsig.expressionevaluator.swing.JScriptEditor;

import org.gvsig.expressionevaluator.swing.JTextComponentProxy;

import org.gvsig.expressionevaluator.swing.impl.elements.DefaultAggregateElements;

import org.gvsig.expressionevaluator.swing.impl.elements.DefaultConstantValueElement;

import org.gvsig.expressionevaluator.swing.impl.elements.DefaultFunctionElement;

import org.gvsig.expressionevaluator.swing.impl.elements.DefaultGroupElement;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.script.Script;

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

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.swing.icontheme.IconTheme;

public class DefaultExpressionEvaluatorSwingManager

        implements ExpressionEvaluatorSwingManager {

    private final Map<String, ElementFactory> elementsFactories;

    private final Map<String, FunctionAdditionalPanelFactory> functionAdditionalPanelFactories;

    public DefaultExpressionEvaluatorSwingManager() {

        this.elementsFactories = new HashMap<>();

        this.functionAdditionalPanelFactories = new HashMap<>();

    }

    @Override

    public List<Element> createElements(Collection<SymbolTable> symbolTables, Predicate<Function>isAllowed) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        Map<String, Function> functions = new HashMap<>();

        for (SymbolTable symbolTable : symbolTables) {

            for (Function function : symbolTable.functions()) {

                if( !function.isHidden() && isAllowed != null && isAllowed.test(function) ) {

                  functions.put(function.name().toUpperCase(), function);

                }

            }

        }

        Map<String, GroupElement> functionGroups = new HashMap<>();

        Map<String, GroupElement> operatorGroups = new HashMap<>();

        for (Function function : functions.values()) {

            if (function.isOperator()) {

                String groupName = function.group();

                GroupElement group = operatorGroups.get(groupName);

                if (group == null) {

                    group = new DefaultGroupElement(groupName);

                    operatorGroups.put(groupName, group);

                }

                group.addElement(new DefaultFunctionElement(function));

            } else {

                String groupName = function.group();

                GroupElement group = functionGroups.get(groupName);

                if (group == null) {

                    group = new DefaultGroupElement(groupName);

                    functionGroups.put(groupName, group);

                }

                group.addElement(new DefaultFunctionElement(function));

            }

        }

        GroupElement builtinFunctions = new DefaultAggregateElements(this, i18n.getTranslation("_Functions"));

        for (GroupElement group : functionGroups.values()) {

            builtinFunctions.addElement(group);

        }

        GroupElement operatorFunctions = new DefaultAggregateElements(this, i18n.getTranslation("_Operators"));

        for (GroupElement group : operatorGroups.values()) {

            operatorFunctions.addElement(group);

        }

        List<Element> elements = new ArrayList<>();

        elements.add(operatorFunctions);

        elements.add(builtinFunctions);

        return elements;

    }

    @Override

    public void registerElement(ElementFactory factory) {

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

    }

    @Override

    public Collection<ElementFactory> getElementFactories() {

        List<ElementFactory> factories = new ArrayList<>();

        factories.addAll(this.elementsFactories.values());

        Collections.sort(factories, new Comparator<ElementFactory>() {

            @Override

            public int compare(ElementFactory o1, ElementFactory o2) {

                return StringUtils.compare(o1.getName(), o2.getName());

            }

        });

        return factories;

    }

    private static class CreateJExpressionBuilderAction extends AbstractAction {

        private JTextComponent jtext;

        public CreateJExpressionBuilderAction(JTextComponent jtext) {

            this.jtext = jtext;

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(

                    Action.ACTION_COMMAND_KEY, 

                    "CreateJExpressionBuilderAction"

            );

            this.putValue(

                    Action.NAME, 

                    i18n.getTranslation("_Show_expression_builder")

            );

            this.putValue(

                    Action.SMALL_ICON, 

                    ToolsSwingLocator.getIconThemeManager().getCurrent().get("picker-expression")

            );

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            WindowManager_v2 winmgr = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

            final JExpressionBuilder panel = ExpressionEvaluatorSwingLocator.getManager().createJExpressionBuilder();

            final Dialog dialog = winmgr.createDialog(

                    panel.asJComponent(),

                    i18n.getTranslation("_Expression_builder"),

                    null, 

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            dialog.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e2) {

                    if( dialog.getAction()==WindowManager_v2.BUTTON_OK ) {

                        if( ExpressionUtils.isDynamicText(jtext.getText())) {

                            jtext.replaceSelection(

                                    panel.getExpression().getPhrase()

                            );

                        } else {

                            jtext.replaceSelection(

                                ExpressionUtils.surroundByDynamicTextTag(

                                    panel.getExpression().getPhrase(),

                                    true

                                )

                            );

                        }

                    }

                }

            });

            dialog.show(WindowManager.MODE.DIALOG);

        }

    }

    @Override

    public Action createJExpressionBuilderAction(JTextComponent jtext) {

        Action action = new CreateJExpressionBuilderAction(jtext);

        return action;

    }

    @Override

    public Action createUniqueTemporalFileAction(JTextComponent jtext, String filename, String fileExtension) {

        return this.createUniqueTemporalFileAction(jtext, new ImmutablePair(filename, fileExtension));

    }

    @Override

    public Action createUniqueTemporalFileAction(JTextComponent jtext, Pair<String, String> nameAndExtension) {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        Action uniqueTemporalFileAction = new AbstractAction(

                i18nManager.getTranslation("_Temporal_file_path")) {

                @Override

                public void actionPerformed(ActionEvent e) {

                    String fileExtension = nameAndExtension.getRight();

                    if( !StringUtils.startsWith(fileExtension, ".") ) {

                        fileExtension = "."+fileExtension;

                    }

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

                        jtext.setText("<%=UNIQUETEMPORARYFILE('" + nameAndExtension.getLeft() + fileExtension + "')%>");

                    }

                }

            };

        return uniqueTemporalFileAction;

    }

    public JExpressionBuilder createJExpressionBuilder(ExpressionBuilderConfig config) {

        DefaultJExpressionBuilder x = new DefaultJExpressionBuilder(

          this, 

          config,

          new DefaultJExpressionBuilderView2() {

            @Override

            public ImageIcon loadImage(String imageName) {

              return loadImageFromIconTheme(imageName);

            }

          }

        );

        return x;

    }

    @Override

    public JExpressionBuilder createJExpressionBuilder() {

        DefaultJExpressionBuilder x = new DefaultJExpressionBuilder(

          this, 

          new DefaultExpressionBuilderConfig(this),

          new DefaultJExpressionBuilderView2() {

            @Override

            public ImageIcon loadImage(String imageName) {

              return loadImageFromIconTheme(imageName);

            }

          }

        );

        return x;

    }

    @Override

    public JExpressionBuilder createJExpressionBuilderAssistant(final JTextComponent expression) {

      return this.createJExpressionBuilderAssistant(() -> expression);

    }

    @Override

    public JExpressionBuilder createJExpressionBuilderAssistant(JTextComponentProxy expression) {

        DefaultJExpressionBuilder x = new DefaultJExpressionBuilder(

          this, 

          new DefaultExpressionBuilderConfig(this),

          new DefaultJExpressionBuilderView3(expression) {

            @Override

            public ImageIcon loadImage(String imageName) {

              return loadImageFromIconTheme(imageName);

            }

          }

        );

        return x;

    }

    public ImageIcon loadImageFromIconTheme(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = this.getClass().getResource(name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

    @Override

    public Element createElement(String name, Object... parameters) {

        ElementFactory factory = this.elementsFactories.get(name.toLowerCase());

        if( factory==null ) {

            throw new RuntimeException("Can't locate element factory '"+name+"'.");

        }

        return factory.createElement(parameters);

    }

    @Override

    public GroupElement createGroupElement(String name) {

        GroupElement e = new DefaultGroupElement(name);

        return e;

    }

    @Override

    public GroupElement createGroupElement(String name, List<Element> elements) {

        GroupElement e = new DefaultGroupElement(this, name, elements);

        return e;

    }

    @Override

    public FunctionElement createFunctionElement(Function function) {

        FunctionElement e = new DefaultFunctionElement(function);

        return e;

    }

    @Override

    public ConstantElement createConstantElement(Object value, String label) {

        ConstantElement e = new DefaultConstantValueElement(

                value, 

                label, 

                null

        );

        return e;

    }

    @Override

    public ConstantElement createConstantElement(Object value, String label, String description) {

        ConstantElement e = new DefaultConstantValueElement(

                value, 

                StringUtils.defaultIfEmpty(label, ""), 

                description

        );

        return e;

    }

//

//    @Override

//    public VariableElement createVariableElement(ExpressionBuilderConfig config, String label, String source, String name, String typeName, String description) {

//        VariableElement e = new DefaultVariableElement(config, label, source, name, typeName, description);

//        return e;

//    }

    @Override

    public ExpressionPickerController createExpressionPickerController(JTextComponent text, JButton button) {

        ExpressionPickerController c = new DefaultExpressionPickerController(this, text, button, null, null);

        return c;

    }

    @Override

    public ExpressionPickerController createExpressionPickerController(JTextComponent text, JButton button, JButton bookmarks, JButton history) {

        ExpressionPickerController c = new DefaultExpressionPickerController(this, text, button, bookmarks, history);

        return c;

    }

    @Override

    public ExpressionPickerController createExpressionPickerController(JComboBox combo, JButton button, JButton bookmarks, JButton history) {

        ExpressionPickerController c = new DefaultExpressionPickerController(this, combo, button, bookmarks, history);

        return c;

    }

    @Override

    public JExpressionPicker createJExpressionPicker() {

        JExpressionPicker x = new DefaultJExpressionPicker(this);

        return x;

    }

    @Override

    public CalculatorController createCalculatorController(JTextComponent text, int dataType) {

        DefaultCalculatorController controller = new DefaultCalculatorController(this,text,dataType);

        return controller;

    }

    @Override

    public void registerAdditionalPanel(FunctionAdditionalPanelFactory factory) {

        if( factory == null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.functionAdditionalPanelFactories.put(factory.getName().toUpperCase(),factory);

    }

    @Override

    public Collection<FunctionAdditionalPanelFactory> getFunctionAdditionalPanelFactories() {

        return this.functionAdditionalPanelFactories.values();

    }

    @Override

    public FunctionAdditionalPanelFactory getFunctionAdditionalPanelFactory(String functionName) {

        FunctionAdditionalPanelFactory factory = this.functionAdditionalPanelFactories.get(functionName.toUpperCase());

        return factory;

    }

    @Override

    public JScriptEditor createJScriptEditor(Script script) {

        JScriptEditorImpl editor = new JScriptEditorImpl(script);

        return editor;

    }

}