Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.swing.impl.syntaxhighlight;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.Container;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import javax.swing.DefaultListCellRenderer;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JViewport;

import javax.swing.KeyStroke;

import javax.swing.SwingUtilities;

import javax.swing.UIDefaults;

import javax.swing.UIManager;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.text.BadLocationException;

import javax.swing.text.Element;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.fife.rsta.ui.CollapsibleSectionPanel;

import org.fife.rsta.ui.search.FindToolBar;

import org.fife.rsta.ui.search.ReplaceToolBar;

import org.fife.rsta.ui.search.SearchEvent;

import org.fife.rsta.ui.search.SearchListener;

import org.fife.ui.autocomplete.AutoCompletion;

import org.fife.ui.autocomplete.BasicCompletion;

import org.fife.ui.autocomplete.Completion;

import org.fife.ui.autocomplete.CompletionProvider;

import org.fife.ui.autocomplete.DefaultCompletionProvider;

import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;

import org.fife.ui.rsyntaxtextarea.SyntaxConstants;

import org.fife.ui.rsyntaxtextarea.TokenMakerFactory;

import org.fife.ui.rtextarea.GutterIconInfo;

import org.fife.ui.rtextarea.RTextScrollPane;

import org.fife.ui.rtextarea.SearchContext;

import org.fife.ui.rtextarea.SearchEngine;

import org.fife.ui.rtextarea.SearchResult;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class JRSyntaxTextArea implements SyntaxtHighlightTextComponent, SearchListener {

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

    public static class MyCheckBox extends JCheckBox {

        private static final String uiClassID = "ToggleButtonUI";

        @Override

        public String getUIClassID() {

            return uiClassID;

        }

    }

    private class MyFindToolBar extends FindToolBar {

        public MyFindToolBar(SearchListener listener) {

            super(listener);

        }

        @Override

        protected JCheckBox createCB(String key) {

            JCheckBox cb = new MyCheckBox();

            cb.setToolTipText(searchMsg.getString(key));

            cb.addActionListener(listener);

            cb.addMouseListener(listener);

            cb.setIcon(getIcon("scripting-search-" + key.toLowerCase()));

            return cb;

        }

    }

    private class MyReplaceToolBar extends ReplaceToolBar {

        public MyReplaceToolBar(SearchListener listener) {

            super(listener);

        }

        @Override

        protected JCheckBox createCB(String key) {

            JCheckBox cb = new MyCheckBox();

            cb.setToolTipText(searchMsg.getString(key));

            cb.addActionListener(listener);

            cb.addMouseListener(listener);

            cb.setIcon(getIcon("scripting-search-" + key.toLowerCase()));

            return cb;

        }

    }

    private class LineTrackerPanel extends JPanel {

        private static final long serialVersionUID = -1923556745197997373L;

        private class Line extends JLabel {

            private static final long serialVersionUID = 8966359978957026490L;

            private final int lineno;

            private final String tag;

            public Line(String tag, final int lineno, int posy, Color color, String tooltip) {

                UIDefaults uidefaults = UIManager.getLookAndFeel().getDefaults();

                this.setBackground((Color) uidefaults.get("EditorPane.background"));

                this.setForeground((Color) uidefaults.get("EditorPane.foreground"));

                this.lineno = lineno;

                this.tag = tag;

                this.setBackground(color);

                this.setBounds(0, posy, 15, 2);

                this.setOpaque(true);

                this.setToolTipText(tooltip);

                this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

                this.addMouseListener(new MouseAdapter() {

                    @Override

                    public void mouseClicked(MouseEvent e) {

                        gotoline(lineno);

                    }

                });

//                Rectangle r = this.getBounds();

//                logger.info("LineTracker: created lineno:"+lineno+", tag:"+tag+", x:"+ r.x + ", y:"+ r.y + ", w:"+ r.width+", h:"+ r.height);

            }

            public int getLineno() {

                return this.lineno;

            }

            public String getTag() {

                return this.tag;

            }

        }

        public LineTrackerPanel() {

            setLayout(null);

        }

        @Override

        public Dimension getPreferredSize() {

            Dimension d = super.getPreferredSize();

            return new Dimension(15, d.height);

        }

        public void addLineTracker(String tag, int lineno, String tooltip, Color color) {

            int posy = (int) (((float)lineno)*this.getSize().height / textArea.getLineCount());

            Line line = new Line(tag,lineno,posy,color,tooltip);

            this.add(line);

            this.repaint();

        }

        public void removeLineTrackers() {

            this.removeAll();

            this.repaint();

        }

        public void removeLineTrackers(String tag) {

            if( StringUtils.isEmpty(tag) ) {

                return;

            }

            List<Line> toremove = new ArrayList<>();

            for( int i=0; i<this.getComponentCount(); i++ ) {

                Line line = (Line) this.getComponent(i);

                if( tag.equalsIgnoreCase(line.getTag()) ) {

                    toremove.add(line);

                }

            }

            for (Line line : toremove) {

                this.remove(line);

            }

            this.repaint();

        }

    }

    private static class IconsTracker {

        private Map<String,Set<GutterIconInfo>>iconInfos = new HashMap<>();

        public IconsTracker() {

        }

        public void add(String tag, GutterIconInfo x) {

            Set<GutterIconInfo> set = this.iconInfos.get(tag);

            if( set == null ) {

                set = new HashSet<>();

                this.iconInfos.put(tag, set);

            }

            set.add(x);

        }

        public void removeAll() {

            this.iconInfos = new HashMap<>();

        }

        public void remove(String tag) {

            this.iconInfos.remove(tag);

        }

        public void remove(String tag, GutterIconInfo x) {

            Set<GutterIconInfo> set = this.iconInfos.get(tag);

            if( set == null ) {

                return;

            }

            set.remove(x);

        }

        public boolean exists(String tag) {

            return this.iconInfos.containsKey(tag);

        }

        public Set<GutterIconInfo> get(String tag) {

            Set<GutterIconInfo> set = this.iconInfos.get(tag);

            return set;

        }

    }

    private final FindToolBar findToolBar;

    private final ReplaceToolBar replaceToolBar;

    private final CollapsibleSectionPanel csp;

    public class DefaultUpdateCaretPositionActionEvent extends ActionEvent implements UpdateCaretPositionActionEvent {

        /**

         *

         */

        private static final long serialVersionUID = 8238486105726094074L;

        int line = -1;

        int column = -1;

        public DefaultUpdateCaretPositionActionEvent(Object source, int id,

                String command, int line, int column) {

            super(source, id, command);

            this.line = line;

            this.column = column;

        }

        public int getLine() {

            return this.line + 1;

        }

        public int getColumn() {

            return this.column;

        }

        public boolean hasLineAndColumn() {

            return this.line >= 0 && this.column >= 0;

        }

    }

    protected ActionListener updateCaretPosition = null;

    protected RSyntaxTextArea textArea = null;

    private final RTextScrollPane scrollPanel;

    private final JPanel panel;

    private final Map<String, String> contentTypeAlias;

    private final IconsTracker iconsTracker = new IconsTracker();

    private LineTrackerPanel lineTrackerPanel;

    private ScriptingUIManager scriptingUIManager;

    public JRSyntaxTextArea() {

        this.contentTypeAlias = new HashMap<>();

        this.contentTypeAlias.put("text/r", SyntaxConstants.SYNTAX_STYLE_C);

        this.contentTypeAlias.put("text/ecmascript", SyntaxConstants.SYNTAX_STYLE_JAVASCRIPT);

        this.contentTypeAlias.put("text/cosa", SyntaxConstants.SYNTAX_STYLE_SQL);

        this.textArea = new RSyntaxTextArea(20, 60);

        UIDefaults uidefaults = UIManager.getLookAndFeel().getDefaults();

        // https://alvinalexander.com/java/java-uimanager-color-keys-list/

        this.textArea.setBackground((Color) uidefaults.get("EditorPane.background"));

        this.textArea.setForeground((Color) uidefaults.get("EditorPane.foreground"));

        this.textArea.setFont((Font) uidefaults.get("EditorPane.font"));

        this.init();

        lineTrackerPanel = new LineTrackerPanel();

        this.scrollPanel = new RTextScrollPane(this.textArea);

        this.scrollPanel.setBackground((Color) uidefaults.get("EditorPane.background"));

        this.scrollPanel.setForeground((Color) uidefaults.get("EditorPane.foreground"));

        this.scrollPanel.setFont((Font) uidefaults.get("EditorPane.font"));

        this.scrollPanel.setIconRowHeaderEnabled(true);

        this.scrollPanel.setLineNumbersEnabled(true);

        this.scrollPanel.setFoldIndicatorEnabled(true);

        panel = new JPanel();

        panel.setLayout(new BorderLayout());

        panel.add(scrollPanel, BorderLayout.CENTER);

        panel.add(lineTrackerPanel,BorderLayout.EAST);

        findToolBar = new MyFindToolBar(this);

        replaceToolBar = new MyReplaceToolBar(this);

        replaceToolBar.setSearchContext(findToolBar.getSearchContext());

        csp = new CollapsibleSectionPanel();

        csp.add(scrollPanel);

        panel.add(csp, BorderLayout.CENTER);

        int ctrl = (KeyEvent.CTRL_MASK | KeyEvent.ALT_MASK);

        KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_F, ctrl);

        csp.addBottomComponent(ks, findToolBar);

        ks = KeyStroke.getKeyStroke(KeyEvent.VK_H, ctrl);

        csp.addBottomComponent(ks, replaceToolBar);

        textArea.addKeyListener(new KeyListener() {

            @Override

            public void keyTyped(KeyEvent ke) {

            }

            @Override

            public void keyPressed(KeyEvent ke) {

                if (ke.getModifiers() == (KeyEvent.CTRL_MASK | KeyEvent.ALT_MASK)) {

                    if (ke.getKeyCode() == KeyEvent.VK_H) {

                        csp.showBottomComponent(replaceToolBar);

                    } else if (ke.getKeyCode() == KeyEvent.VK_F) {

                        csp.showBottomComponent(findToolBar);

                    }

                }

            }

            @Override

            public void keyReleased(KeyEvent ke) {

            }

        });

    }

    protected void init() {

        textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_PYTHON);

        textArea.setCodeFoldingEnabled(true);

        textArea.setClearWhitespaceLinesEnabled(true);

        textArea.setAutoIndentEnabled(true);

        textArea.setCloseCurlyBraces(true);

        textArea.setWhitespaceVisible(true);

        textArea.setAnimateBracketMatching(true);

        textArea.setBracketMatchingEnabled(true);

        textArea.setAutoIndentEnabled(true);

        textArea.setTabsEmulated(true);

        textArea.setTabSize(2);

        textArea.setAntiAliasingEnabled(true);

        textArea.addCaretListener(new CaretListener() {

            public void caretUpdate(CaretEvent e) {

                if (updateCaretPosition == null) {

                    return;

                }

                updateCaretPosition.actionPerformed(

                        new DefaultUpdateCaretPositionActionEvent(textArea, 1, "position", textArea.getCaretLineNumber(), textArea.getCaretOffsetFromLineStart())

                );

            }

        });

        CompletionProvider provider = new MyCompletionProvider(python_keywords);

        AutoCompletion ac = new AutoCompletion(provider);

        ac.setListCellRenderer(new MyListCellRenderer());

        ac.setTriggerKey(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.CTRL_DOWN_MASK));

        ac.install(textArea);

    }

    private ScriptingUIManager getUIManager() {

        if( this.scriptingUIManager==null ) {

            this.scriptingUIManager = ScriptingSwingLocator.getUIManager();

        }

        return this.scriptingUIManager;

    }

    private ImageIcon getIcon(String key) {

        ImageIcon icon = this.getUIManager().getIcon(key);

        return icon;

    }

    private static class MyListCellRenderer extends DefaultListCellRenderer {

        @Override

        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

            Component comp = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); //To change body of generated methods, choose Tools | Templates.

            ((JLabel) comp).setIcon(((Completion) value).getIcon());

            return comp;

        }

    }

    private String[] python_keywords = new String[]{

        "except",

        "class",

        "continue",

        "else",

        "finally",

        "if",

        "elif",

        "in",

        "return",

        "raise",

        "try",

        "while",

        "def",

        "print",

        "globals",

        "for",

        "pass",

        "from",

        "import",

        "True",

        "False",

        "None",

        "self",

        "break",

        "__init__",

        "__len__",

        "__str__",

        "__repr__",

        "__call__",

        "__iter__",

        "__class__",

        "__getattr__",

        "__setattr__",

        "__delattr__",

        "__getitem__",

        "__setitem__",

        "__delitem__",

        "__getslice__",

        "__setslice__",

        "__delslice__",

        "__getattribute__",

        "__setattribute__",

        "__contains__",

        "__reduce__",

        "__cmp__",

        "__eq__",

        "__ne__",

        "__lt__",

        "__le__",

        "__gt__",

        "__ge__",

        "__mul__",

        "__imul__",

        "__rmul__",

        "__add__",

        "__iadd__",

        "__radd__",

        "__mod__",

        "__rmod__",

        "int",

        "unicode",

        "str",

        "float",

        "long",

        "list",

        "tuple",

        "dict",

        "iter",

        "vars",

        "isinstance",

        "dir",

        "repr",

        "reduce",

        "zip",

        "chr",

        "hex",

        "id",

        "max",

        "min",

        "oct",

        "pow",

        "ord",

        "unichr",

        "range",

        "xrange",

        "abs",

        "len",

        "apply",

        "open",

        "getattr",

        "setattr",

        "hasattr"

    };

    private class MyCompletionProvider extends DefaultCompletionProvider {

        private List<Completion> keywords;

        private Icon keywordIcon;

        private Icon wordIcon;

        public MyCompletionProvider(String[] keywords) {

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

            URL url = loader.getResource("org/gvsig/scripting/swing/impl/syntaxhighlight/images/autocompletion_keywords.png");

            if (url != null) {

                keywordIcon = new ImageIcon(url);

            }

            url = loader.getResource("org/gvsig/scripting/swing/impl/syntaxhighlight/images/autocompletion_words.png");

            if (url != null) {

                wordIcon = new ImageIcon(url);

            }

            this.keywords = new ArrayList<>();

            for (String keyword : keywords) {

                BasicCompletion completion = new BasicCompletion(this, keyword);

                completion.setIcon(keywordIcon);

                this.keywords.add(completion);

            }

        }

        @Override

        protected List<Completion> getCompletionsImpl(JTextComponent comp) {

            TreeSet all = new TreeSet();

            all.addAll(this.keywords);

            String s = comp.getText();

            String[] x = StringUtils.split(s, "\\ \n\t\r!\"><'@#|$%&/()=??,.;:{}[]*-+");

            TreeSet<String> words = new TreeSet(new Comparator<String>() {

                @Override

                public int compare(String o1, String o2) {

                    return o1.compareTo(o2);

                }

            });

            words.addAll(Arrays.asList(x));

            for (String word : words) {

                BasicCompletion completion = new BasicCompletion(this, word);

                completion.setIcon(wordIcon);

                completion.setRelevance(10);

                all.add(completion);

            }

            completions = new ArrayList<>();

            completions.addAll(all);

            return super.getCompletionsImpl(comp);

        }

    }

    private String normalizeContentType(String s) {

        s = s.toLowerCase();

        if (this.contentTypeAlias.containsKey(s)) {

            s = this.contentTypeAlias.get(s);

        }

        return s;

    }

    public void setContentType(String contentType) {

        TokenMakerFactory factory = TokenMakerFactory.getDefaultInstance();

        Set<String> mimetypes = factory.keySet();

        String mimetype = this.normalizeContentType(contentType);

        if( !mimetypes.contains(mimetype)) {

          mimetype = mimetype.replace("-source", "");

          if( !mimetypes.contains(mimetype)) {

            mimetype = mimetype.replace("/x-", "/");

            if( !mimetypes.contains(mimetype)) {

              mimetype = this.normalizeContentType(contentType);

            }

          }

        }

        this.textArea.setSyntaxEditingStyle(mimetype);

    }

    public JScrollPane getJScrollPane() {

        return this.scrollPanel;

    }

    public JTextComponent getJTextComponent() {

        return this.textArea;

    }

    @Override

    public JComponent asJComponent() {

        return this.panel;

    }

    public String getContentType() {

        return this.textArea.getSyntaxEditingStyle();

    }

    public void addUpdateCaretPositionActionListener(ActionListener updateCaretPosition) {

        this.updateCaretPosition = updateCaretPosition;

    }

    public void setText(String text) {

        this.textArea.setText(text);

    }

    public String getText() {

        return this.textArea.getText();

    }

    public void addKeyListener(KeyListener keyListener) {

        this.textArea.addKeyListener(keyListener);

    }

    @Override

    public void searchEvent(SearchEvent e) {

        SearchEvent.Type type = e.getType();

        SearchContext context = e.getSearchContext();

        SearchResult result = null;

        switch (type) {

            default: // Prevent FindBugs warning later

            case MARK_ALL:

                result = SearchEngine.markAll(textArea, context);

                break;

            case FIND:

                result = SearchEngine.find(textArea, context);

                if (!result.wasFound()) {

                    textArea.getCaret().setDot(0);

                    result = SearchEngine.find(textArea, context);

                    if (!result.wasFound()) {

                        UIManager.getLookAndFeel().provideErrorFeedback(textArea);

                    }

                }

                break;

            case REPLACE:

                result = SearchEngine.replace(textArea, context);

                if (!result.wasFound()) {

                    UIManager.getLookAndFeel().provideErrorFeedback(textArea);

                }

                break;

            case REPLACE_ALL:

                result = SearchEngine.replaceAll(textArea, context);

                JOptionPane.showMessageDialog(null, result.getCount()

                        + " occurrences replaced.");

                break;

        }

        String text = null;

        if (result.wasFound()) {

            text = "Text found; occurrences marked: " + result.getMarkedCount();

        } else if (type == SearchEvent.Type.MARK_ALL) {

            if (result.getMarkedCount() > 0) {

                text = "Occurrences marked: " + result.getMarkedCount();

            } else {

                text = "";

            }

        } else {

            text = "Text not found";

        }

        //setMessage(text);

    }

    @Override

    public String getSelectedText() {

        return textArea.getSelectedText();

    }

    /**

     *

     */

    @Override

    public void discardAllEdits() {

        this.textArea.discardAllEdits();

    }

    @Override

    public void removeTrackingIcons() {

        this.scrollPanel.getGutter().removeAllTrackingIcons();

        this.iconsTracker.removeAll();

        this.lineTrackerPanel.removeLineTrackers();

    }

    @Override

    public void addLineTrackingIcon(String tag, int line, Icon icon, String tip) {

        addLineTrackingIcon(tag, line, icon, tip, Color.BLUE.darker());

    }

    @Override

    public void addLineTrackingIcon(String tag, int line, Icon icon, String tip, Color color) {

        try {

            GutterIconInfo x = this.scrollPanel.getGutter().addLineTrackingIcon(line,icon,tip);

            this.iconsTracker.add(tag, x);

            this.lineTrackerPanel.addLineTracker(tag, line, tip, color);

        } catch (BadLocationException ex) {

            throw new RuntimeException("Can't add tracking icon with tag '"+tag+"' in line '"+line+"', tip='"+tip+"'", ex);

        }

    }

    @Override

    public void removeTrackingIcons(String tag) {

        Set<GutterIconInfo> icontags = this.iconsTracker.get(tag);

        if( icontags!=null ) {

            for (GutterIconInfo icontag : icontags) {

                this.scrollPanel.getGutter().removeTrackingIcon(icontag);

            }

            this.iconsTracker.remove(tag);

        }

        this.lineTrackerPanel.removeLineTrackers(tag);

    }

    @Override

    public void gotoline(final int line) {

        JTextComponent component = getJTextComponent();

        Element root = component.getDocument().getDefaultRootElement();

        int lineno = Math.max(line, 1);

        int maxlines = root.getElementCount();

        lineno = Math.min(lineno, maxlines);

        int startOfLineOffset = root.getElement( lineno - 1 ).getStartOffset();

        component.setCaretPosition( startOfLineOffset );

        Container container = SwingUtilities.getAncestorOfClass(JViewport.class, component);

        if (container == null) {

            return;

        }

        try {

            Rectangle r = component.modelToView(component.getCaretPosition());

            JViewport viewport = (JViewport) container;

            int extentHeight = viewport.getExtentSize().height;

            int viewHeight = viewport.getViewSize().height;

            int y = Math.max(0, r.y - ((extentHeight - r.height) / 2));

            y = Math.min(y, viewHeight - extentHeight);

            viewport.setViewPosition(new Point(0, y));

        } catch (BadLocationException ble) {

            ble.printStackTrace();

        }

        try {

            component.setCaretPosition( startOfLineOffset+1 );

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}