Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.swing.impl;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import javax.help.HelpSet;

import javax.help.HelpSetException;

import javax.help.JHelp;

import javax.help.ScriptingHelpModel;

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JPanel;

import org.gvsig.about.AboutLocator;

import org.gvsig.about.AboutManager;

import org.gvsig.scripting.ScriptingDialog;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingHelpManager;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.scripting.swing.api.CreateComponentListener;

import org.gvsig.scripting.swing.api.EditorFactory;

import org.gvsig.scripting.swing.api.JCodeEditor;

import org.gvsig.scripting.swing.api.JDialogEditor;

import org.gvsig.scripting.swing.api.JEditor;

import org.gvsig.scripting.swing.api.JScriptingBrowser;

import org.gvsig.scripting.swing.api.JScriptingComposer;

import org.gvsig.scripting.swing.api.JScriptingConsole;

import org.gvsig.scripting.swing.api.JScriptingLauncher;

import org.gvsig.scripting.swing.api.JThinG;

import org.gvsig.scripting.swing.api.JThinlet;

import org.gvsig.scripting.swing.api.ScriptingUIManager;

import org.gvsig.scripting.swing.api.ScriptingUIManager.MenuEntry;

import org.gvsig.scripting.swing.api.SyntaxtHighlightTextComponent;

import org.gvsig.scripting.swing.impl.composer.DefaultJScriptingComposer;

import org.gvsig.scripting.swing.impl.composer.editors.DialogEditor;

import org.gvsig.scripting.swing.impl.composer.editors.DialogEditorFactory;

import org.gvsig.scripting.swing.impl.composer.editors.ExternalFileEditorFactory;

import org.gvsig.scripting.swing.impl.composer.editors.ScriptEditor;

import org.gvsig.scripting.swing.impl.composer.editors.ScriptEditorFactory;

import org.gvsig.scripting.swing.impl.composer.editors.TextEditorFactory;

import org.gvsig.scripting.swing.impl.syntaxhighlight.JEditorPaneSyntaxHighlighting;

import org.gvsig.scripting.swing.impl.syntaxhighlight.JRSyntaxTextArea;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultScriptingUIManager implements ScriptingUIManager {

    private final static Logger logger = LoggerFactory.getLogger(DefaultScriptingUIManager.class);

    private final ScriptingManager manager;

    private final Map<String, URL> userHelps = new HashMap<>();

    private I18nManager i18nManager;

    private WindowManager windowsManager = null;

    private final Map<String,Action> composerTools = new HashMap<>();

    private final Map<String,MenuEntry> composerMenus = new HashMap<>();

    private JScriptingComposer activeComposer;

    private Set<CreateComponentListener> createComponentListeners;    

    private final Map<String,EditorFactory> editorFactories = new HashMap<>();

    private List<EditorFactory> editorFactoriesOrderer = null;

    private static class DefaultMenuEntry implements MenuEntry {

        private final Action action;

        private final String text;

        public DefaultMenuEntry(String text, Action action) {

            this.text = text;

            this.action = action;

        }

        @Override

        public String getText() {

            return this.text;

        }

        @Override

        public Action getAction() {

            return this.action;

        }

    }

    public DefaultScriptingUIManager() {

        this.manager = ScriptingLocator.getManager();

        this.manager.put("ScriptingUIManager", this);

        this.i18nManager = ToolsLocator.getI18nManager();

        this.registerEditor(new DialogEditorFactory());

        this.registerEditor(new ScriptEditorFactory());

        this.registerEditor(new TextEditorFactory());

        this.registerEditor(new ExternalFileEditorFactory());

    }

    @Override

    public void addCreatedComponentListener(CreateComponentListener listener) {

        if( this.createComponentListeners==null ) {

            this.createComponentListeners = new HashSet<>();

        }

        this.createComponentListeners.add(listener);

    }

    @Override

    public void removeCreatedComponentListener(CreateComponentListener listener) {

        if( this.createComponentListeners==null ) {

            return;

        }

        this.createComponentListeners.remove(listener);

    }

    public void fireCreateComponent(Component component) {

        if (this.createComponentListeners == null) {

            return;

        }

        for (CreateComponentListener listener : this.createComponentListeners) {

            try {

                listener.componentCreated(component);

            } catch (Throwable th) {

            }

        }

    }

    @Override

    public JScriptingComposer createComposer() {

        JScriptingComposer composer = new DefaultJScriptingComposer(this);

        fireCreateComponent(composer);

        return composer;

    }

    @Override

    public JPanel createInstaller() {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public JScriptingLauncher createLauncher() {

        JScriptingLauncher launcher = new DefaultJScriptingLauncher(this);

        fireCreateComponent(launcher);

        return launcher;

    }

    @Override

    public ImageIcon getIcon(String name) {

        return this.getIcon(name, null);

    }

    @Override

    public ImageIcon getIcon(String name, String size) {

        if (name == null) {

            return new ImageIcon();

        }

        String tamanyo = "16x16/";

        if (size != null && size.equals("big")) {

            tamanyo = "32x32/";

        }

        ClassLoader loader = this.getClass().getClassLoader();

        URL url = loader.getResource("org/gvsig/scripting/images/" + tamanyo + name + ".png");

        if (url == null) {

            url = loader.getResource("org/gvsig/scripting/images/" + tamanyo + "image-missing.png");

        }

        if (url == null) {

            return new ImageIcon();

        }

        return new ImageIcon(url);

    }

    @Override

    public ScriptingManager getManager() {

        return this.manager;

    }

    @Override

    public JPanel getHelp() {

        JPanel panel = new JPanel();

        panel.setLayout(new BorderLayout());

        ScriptingHelpManager helpManager = this.getManager().getHelpManager();

        HelpSet hs = helpManager.getHelpSet();

        JHelp jhelp = new JHelp(

                new ScriptingHelpModel(hs, helpManager),

                null,

                hs.getDefaultPresentation()

        );

        panel.add(jhelp, BorderLayout.CENTER);

        panel.setPreferredSize(new Dimension(800, 600));

        return panel;

    }

    public String[] getPrerreferedLanguages() {

        String curr = Locale.getDefault().getLanguage().toLowerCase();

        if (curr.equals("gl")) {

            return new String[]{"gl", "es", "en"};

        }

        if (curr.equals("ca")) {

            return new String[]{"ca", "es", "en"};

        }

        if (curr.equals("eu")) {

            return new String[]{"eu", "es", "en"};

        }

        if (curr.equals("va")) {

            return new String[]{"va", "ca", "es", "en"};

        }

        return new String[]{curr, "en", "es"};

    }

    @Override

    public JPanel getUserHelp() {

        String[] langs = this.getPrerreferedLanguages();

        URL url = null;

        for (String lang : langs) {

            url = this.userHelps.get(lang);

            if (url != null) {

                break;

            }

        }

        if (url == null) {

            logger.warn("Can't have help");

            return null;

        }

        URL[] urls = new URL[1];

        urls[0] = url;

        ClassLoader loader = new URLClassLoader(urls, this.getClass().getClassLoader());

        HelpSet helpSet;

        try {

            URL resource;

            resource = loader.getResource("org/gvsig/scripting/help/help.hs");

            helpSet = new HelpSet(loader, resource);

        } catch (HelpSetException e) {

            logger.warn("Can't load helpset '" + url.toString() + "'.", e);

            return null;

        }

        JPanel panel = new JPanel();

        panel.setLayout(new BorderLayout());

        panel.add(new JHelp(helpSet), BorderLayout.CENTER);

        panel.setPreferredSize(new Dimension(800, 600));

        return panel;

    }

    @Override

    public void addUserHelp(String langName, URL resource) {

        this.userHelps.put(langName.toLowerCase(), resource);

    }

    @Override

    public AboutManager getAboutManager() {

        return AboutLocator.getManager();

    }

    private void showWindow(JComponent panel, String title, WindowManager.MODE mode) {

        WindowManager winmanager = this.getWindowManager();

        if( winmanager instanceof WindowManager_v2 ) {

            ((WindowManager_v2)winmanager).showWindow(panel, title, mode, getIcon("scripting_python").getImage());

        } else {

            winmanager.showWindow(panel, title, mode);

        }

    }

    @Override

    public void showDialog(JComponent panel, String title) {

        this.showWindow(panel, title, WindowManager.MODE.DIALOG);

    }

    @Override

    public void showWindow(JComponent panel, String title) {

        this.showWindow(panel, title, WindowManager.MODE.WINDOW);

    }

    @Override

    public void showTool(JComponent panel, String title) {

        this.showWindow(panel, title, WindowManager.MODE.TOOL);

    }

    @Override

    public JScriptingBrowser createBrowser(ScriptingFolder root, boolean foldersOnly) {

        JScriptingBrowser browser = new DefaultJScriptingBrowser(this, root, foldersOnly);

        fireCreateComponent(browser);

        return browser;

    }

    @Override

    public JScriptingBrowser createBrowser(ScriptingFolder root) {

        return this.createBrowser(root,false);

    }

    @Override

    public JCodeEditor createJCodeEditor(ScriptingScript script) {

        JCodeEditor editor = new ScriptEditor(this, script);

        fireCreateComponent(editor);

        return editor;

    }

    @Override

    public JDialogEditor createJDialogEditor(ScriptingDialog script) {

        return new DialogEditor(this, script);

    }

    @Override

    public JThinG createJThinG() {

        JThinG thing = new DefaultJThinG();

        return thing;

    }

    @Override

    public JThinlet createJThinlet() {

        JThinlet thinlet = new DefaultJThinlet();

        return thinlet;

    }

    @Override

    public SyntaxtHighlightTextComponent createSyntaxHighlightingPanel() {

        try {

            return new JRSyntaxTextArea();

        } catch (Throwable t) {

            logger.info("Can't create advanced SyntaxHighlightingPanel.", t);

            return new JEditorPaneSyntaxHighlighting();

        }

    }

    @Override

    public String getTranslation(String key) {

        if (this.i18nManager == null) {

            this.i18nManager = ToolsLocator.getI18nManager();

        }

        return i18nManager.getTranslation(key);

    }

    @Override

    public WindowManager getWindowManager() {

        if( this.windowsManager==null ) {

            this.windowsManager = ToolsSwingLocator.getWindowManager();

        }

        return this.windowsManager;

    }

    @Override

    public void setWindowManager(WindowManager windowsManager) {

        this.windowsManager = windowsManager;

    }

    @Override

    public JScriptingConsole createJScriptingConsole() {

        return this.createJScriptingConsole(true);

    }

    @Override

    public JScriptingConsole createJScriptingConsole(boolean captureOutput) {

        JScriptingConsole console = new DefaultJScriptingConsole(captureOutput);

        fireCreateComponent(console);

        return console;

    }

    @Override

    public void addComposerMenu(String text, Action action) {

        String name = (String) action.getValue(Action.ACTION_COMMAND_KEY);

        this.composerMenus.put(name,new DefaultMenuEntry(text,action));

    }

    @Override

    public void addComposerTool(Action action) {

        String name = (String) action.getValue(Action.ACTION_COMMAND_KEY);

        this.composerTools.put(name,action);

    }

    @Override

    public Collection<MenuEntry> getComposerMenus() {

        return this.composerMenus.values();

    }

    @Override

    public Collection<Action> getComposerTools() {

        return this.composerTools.values();

    }

    @Override

    public JEditor createEditor(ScriptingUnit unit) {

        JEditor editor = null;

        for (EditorFactory factory : this.getEditorFactories() ) {

            try {

                if( factory.canCreate(unit) ) {

                    editor = factory.create(unit);

                    fireCreateComponent(editor);

                    break;

                }

            } catch(Exception ex) {

                logger.warn("Can't create an editor with factory '"+factory.getClass().getName()+"' for '"+unit.getClass().getName()+"'.",ex);

            }

        }

        return editor;

    }

    @Override

    public boolean hasEditor(ScriptingUnit unit) {

        if( unit == null ) {

            return false;

        }

        for (EditorFactory factory : this.getEditorFactories() ) {

            try {

                if( factory.canCreate(unit) ) {

                    return true;

                }

            } catch(Exception ex) {

                logger.warn("Can't check if factory '"+factory.getClass().getName()+"' can create an editor for '"+unit.getClass().getName()+"'.",ex);

            }

        }

        return false;

    }

    public void setActiveComposer(JScriptingComposer composer) {

        this.activeComposer = composer;

    }

    @Override

    public JScriptingComposer getActiveComposer() {

        return this.activeComposer;

    }

    @Override

    public void registerEditor(EditorFactory factory) {

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

        this.editorFactoriesOrderer = null;

    }

    @Override

    public List<EditorFactory> getEditorFactories() {

        if( this.editorFactoriesOrderer == null ) {

            this.editorFactoriesOrderer = new ArrayList<>(this.editorFactories.values());

            Collections.sort(editorFactoriesOrderer, new Comparator<EditorFactory>() {

                @Override

                public int compare(EditorFactory o1, EditorFactory o2) {

                    return o2.getPriority() - o1.getPriority();

                }

            });

        }

        return editorFactoriesOrderer;

    }

}