/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.core.output2;

import java.awt.Color;
import java.awt.Dialog;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.EventQueue;
import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.CharConversionException;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JSeparator;
import javax.swing.KeyStroke;
import javax.swing.RootPaneContainer;
import javax.swing.SwingUtilities;
import javax.swing.UIDefaults;
import javax.swing.UIManager;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.options.OptionsDisplayer;
import org.netbeans.core.options.keymap.api.KeyStrokeUtils;
import org.netbeans.core.output2.Controller.ControllerOutputEvent;
import org.netbeans.core.output2.ui.AbstractOutputPane;
import org.netbeans.core.output2.ui.AbstractOutputTab;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.actions.FindAction;
import org.openide.awt.StatusDisplayer;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.windows.IOContainer;
import org.openide.windows.OutputListener;
import org.openide.windows.WindowManager;
import org.openide.xml.XMLUtil;

import static org.netbeans.core.output2.OutputTab.ACTION.*;
import org.netbeans.core.output2.options.OutputOptions;
import org.netbeans.core.output2.ui.OutputKeymapManager;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;
import org.openide.windows.IOColors;
import org.openide.windows.OutputEvent;


/**
 * A component representing one tab in the output window.
 */
final class OutputTab extends AbstractOutputTab implements IOContainer.CallBacks {
    private static final RequestProcessor RP =
            new RequestProcessor("OutputTab");                          //NOI18N
    private final NbIO io;
    private OutWriter outWriter;
    private PropertyChangeListener optionsListener;
    private volatile boolean actionsLoaded = false;

    OutputTab(NbIO io) {
        this.io = io;
        if (Controller.LOG) Controller.log ("Created an output component for " + io);
        outWriter = ((NbWriter) io.getOut()).out();
        OutputDocument doc = new OutputDocument(outWriter);
        setDocument(doc);
        applyOptions();
        initOptionsListener();
        loadAndInitActions();
    }

    private void applyOptions() {
        Lines lines = getDocumentLines();
        if (lines != null) {
            OutputOptions opts = io.getOptions();
            lines.setDefColor(IOColors.OutputType.OUTPUT,
                    opts.getColorStandard());
            lines.setDefColor(IOColors.OutputType.ERROR,
                    opts.getColorError());
            lines.setDefColor(IOColors.OutputType.INPUT,
                    opts.getColorInput());
            lines.setDefColor(IOColors.OutputType.HYPERLINK,
                    opts.getColorLink());
            lines.setDefColor(IOColors.OutputType.HYPERLINK_IMPORTANT,
                    opts.getColorLinkImportant());
            Color bg = io.getOptions().getColorBackground();
            getOutputPane().getFoldingSideBar().setForeground(
                    opts.getColorStandard());
            setTextViewBackground(getOutputPane().getTextView(), bg);
            getOutputPane().setViewFont(
                    io.getOptions().getFont(getOutputPane().isWrapped()));
        }
    }

    /**
     * Set text view background color correctly. See bug #225829.
     */
    private void setTextViewBackground(JTextComponent textView, Color bg) {
        getOutputPane().getTextView().setBackground(bg);
        getOutputPane().getFoldingSideBar().setBackground(bg);
        if ("Nimbus".equals(UIManager.getLookAndFeel().getName())) { //NOI18N
            UIDefaults defaults = new UIDefaults();
            defaults.put("EditorPane[Enabled].backgroundPainter", bg);  //NOI18N
            textView.putClientProperty("Nimbus.Overrides", defaults);   //NOI18N
            textView.putClientProperty(
                    "Nimbus.Overrides.InheritDefaults", true);          //NOI18N
            textView.setBackground(bg);
        }
    }

    private final TabAction action(ACTION a) {
        return actions.get(a);
    }

    private void installKBActions() {
        for (ACTION a : actionsToInstall) {
            installKeyboardAction(action(a));
        }
    }

    @Override
    public void setDocument (Document doc) {
        if (Controller.LOG) Controller.log ("Set document on " + this + " with " + io);
        assert SwingUtilities.isEventDispatchThread();
        Document old = getDocument();
        hasOutputListeners = false;
        super.setDocument(doc);
        if (old != null && old instanceof OutputDocument) {
            ((OutputDocument) old).dispose();
        }
        applyOptions();
    }

    public void reset() {
        if (origPane != null) {
            setFilter(null, false, false);
        }
        // get new OutWriter
        outWriter = io.out();

        // Workaround for bug 242979.
        Document actualDocument = getDocument();
        if (actualDocument instanceof OutputDocument) {
            OutputDocument od = (OutputDocument) actualDocument;
            if (od.getWriter() == outWriter) {
                return;
            }
        }
        setDocument(new OutputDocument(outWriter));
        applyOptions();
    }

    public OutputDocument getDocument() {
        Document d = getOutputPane().getDocument();
        if (d instanceof OutputDocument) {
            return (OutputDocument) d;
        }
        return null;
    }

    protected AbstractOutputPane createOutputPane() {
        return new OutputPane(this);
    }

    public void inputSent(String txt) {
        if (Controller.LOG) Controller.log("Input sent on OutputTab: " + txt);
        getOutputPane().lockScroll();
        NbIO.IOReader in = io.in();
        if (in != null) {
            if (Controller.LOG) Controller.log("Sending input to " + in);
            in.pushText(txt + "\n");
            outWriter.print(txt, null, false, null, null, OutputKind.IN, true);
        }
    }

    protected void inputEof() {
        if (Controller.LOG) Controller.log ("Input EOF");
        NbIO.IOReader in = io.in();
        if (in != null) {
            in.eof();
        }
    }

    public void hasSelectionChanged(boolean val) {
        if (isShowing() && actionsLoaded) {
            actions.get(ACTION.COPY).setEnabled(val);
            actions.get(ACTION.SELECT_ALL).setEnabled(!getOutputPane().isAllSelected());
        }
    }

    public NbIO getIO() {
        return io;
    }
    
    void requestActive() {
        io.getIOContainer().requestActive();
    }

    public void lineClicked(int line, int pos) {
        OutWriter out = getOut();
        int range[] = new int[2];
        OutputListener l = out.getLines().getListener(pos, range);
        if (l != null) {
            int size = out.getLines().getCharCount();
            assert range[1] < size : "Size: " + size + " range: " + range[0] + " " + range[1];
            ControllerOutputEvent oe = new ControllerOutputEvent(io, out, line);
            l.outputLineAction(oe);
            //Select the text on click if it is still visible
            if (getOutputPane().getLength() >= range[1]) { // #179768
                getOutputPane().sendCaretToPos(range[0], range[1], true);
            }
        }
    }

    void enterPressed(int caretMark, int caretDot) {
        int start, end;
        if (caretMark < caretDot) {
            start = caretMark;
            end = caretDot;
        } else {
            start = caretDot;
            end = caretMark;
        }
        if (getOut().getLines().isListener(start, end)) {
            int[] range = new int[2];
            OutputListener listener = getOut().getLines().nearestListener(
                    start, false, range);
            if (listener != null && range[0] <= start && range[1] >= end) {
                int line = getOut().getLines().getLineAt(start);
                OutputEvent oe = new ControllerOutputEvent(io, line);
                listener.outputLineAction(oe);
            }
        }
    }

    @Override
    public String toString() {
        return "OutputTab@" + System.identityHashCode(this) + " for " + io;
    }

    private boolean hasOutputListeners = false;

    public void documentChanged(OutputPane pane) {
        if (filtOut != null && pane == origPane) {
            filtOut.readFrom(outWriter);
        }
        boolean hadOutputListeners = hasOutputListeners;
        hasOutputListeners = getOut() != null && (getOut().getLines().firstListenerLine() >= 0 || getOut().getLines().firstImportantListenerLine() >= 0);
        if (hasOutputListeners != hadOutputListeners) {
            hasOutputListenersChanged(hasOutputListeners);
        }

        IOContainer ioContainer = io.getIOContainer();
        if (io.isFocusTaken()) {
	    // The following two lines pulled up from select per bug#185209
	    ioContainer.open();
	    // ioContainer.requestVisible();

            ioContainer.select(this);
            ioContainer.requestVisible();
        }
        Controller.getDefault().updateName(this);
        if (this == ioContainer.getSelected() && ioContainer.isActivated()) {
            updateActions();
        }
    }

    /**
     * Called when the output stream has been closed, to navigate to the
     * first line which shows an error (if any).
     */
    private void navigateToFirstErrorLine() {
        OutWriter out = getOut();
        if (out != null) {
            int line = out.getLines().firstImportantListenerLine();
            if (Controller.LOG) {
                Controller.log("NAV TO FIRST LISTENER LINE: " + line);
            }
            if (line >= 0) {
                getOutputPane().sendCaretToLine(line, false);
            }
        }
    }

     void hasOutputListenersChanged(boolean hasOutputListeners) {
        if (hasOutputListeners && getOutputPane().isScrollLocked()) {
            navigateToFirstErrorLine();
        }
    }

    public void activated() {
        updateActions();
    }

    public void closed() {
        io.setClosed(true);
        io.setStreamClosed(true);
        Controller.getDefault().removeTab(io);
        NbWriter w = io.writer();
        if (w != null && w.isClosed()) {
            //Will dispose the document
            setDocument(null);
            io.dispose();
        } else if (w != null) {
            //Something is still writing to the stream, but we're getting rid of the tab.  Don't dispose
            //the writer, just kill the tab's document
            if (getOut() != null) {
                getOut().setDisposeOnClose(true);
            }
            getDocument().disposeQuietly();
            NbIOProvider.dispose(io);
        }
    }

    public void deactivated() {
    }

    public void selected() {
    }

    /**
     * Determine if the new caret position is close enough that the scrollbar should be re-locked
     * to the end of the document.
     *
     * @param dot The caret position
     * @return if it should be locked
     */
    public boolean shouldRelock(int dot) {
        OutWriter w = getOut();
        if (w != null && !w.isClosed()) {
            int dist = Math.abs(w.getLines().getCharCount() - dot);
            return dist < 100;
        }
        return false;
    }

    /**
     * Flag used to block navigating the editor to the first error line when
     * selecting the error line in the output window after a build (or maybe
     * it should navigate the editor there?  Could be somewhat rude...)
     */
    boolean ignoreCaretChanges = false;

    /**
     * Called when the text caret has changed position - will call OutputListener.outputLineSelected if
     * there is a listener for that position.
     *
     * @param pos The line the caret is in
     */
    int lastCaretListenerRange[];
    void caretPosChanged(int pos) {
        if (!ignoreCaretChanges) {
            if (lastCaretListenerRange != null && pos >= lastCaretListenerRange[0] && pos < lastCaretListenerRange[1]) {
                return;
            }
            OutWriter out = getOut();
            if (out != null) {
                int[] range = new int[2];
                OutputListener l = out.getLines().getListener(pos, range);
                if (l != null) {
                    ControllerOutputEvent oe = new ControllerOutputEvent(io, out.getLines().getLineAt(pos));
                    l.outputLineSelected(oe);
                    lastCaretListenerRange = range;
                } else {
                    lastCaretListenerRange = null;
                }
            }
        }
    }

    private void sendCaretToError(boolean backward) {
        OutWriter out = getOut();
        if (out != null) {
            AbstractOutputPane op = getOutputPane();
            int selStart = op.getSelectionStart();
            int selEnd = op.getSelectionEnd();
            int pos = op.getCaretPos();

            // check if link is selected
            if (selStart != selEnd && pos == selStart && out.getLines().isListener(selStart, selEnd)) {
                pos = backward ? selStart - 1 : selEnd + 1;
            }
            int[] lpos = new int[2];
            OutputListener l = out.getLines().nearestListener(pos, backward, lpos);
            if (l != null) {
                op.sendCaretToPos(lpos[0], lpos[1], true);
                if (!io.getIOContainer().isActivated()) {
                    ControllerOutputEvent ce = new ControllerOutputEvent(io,  out.getLines().getLineAt(lpos[0]));
                    l.outputLineAction(ce);
                }
            }
        }
    }

    /**
     * Searching from current position
     * @param reversed true for reverse search
     * @return true if found
     */
    private boolean find(boolean reversed) {
        OutWriter out = getOut();
        if (out != null) {
            String lastPattern = FindDialogPanel.result();
            if (lastPattern == null) {
                return false;
            }
            int pos = reversed ? getOutputPane().getSelectionStart() : getOutputPane().getCaretPos();
            if (pos > getOutputPane().getLength() || pos < 0) {
                pos = 0;
            }
            boolean regExp = FindDialogPanel.regExp();
            boolean matchCase = FindDialogPanel.matchCase();
            int[] sel = reversed ? out.getLines().rfind(pos, lastPattern, regExp, matchCase)
                    : out.getLines().find(pos, lastPattern, regExp, matchCase);
            String appendMsg = null;
            if (sel == null) {
                sel = reversed ? out.getLines().rfind(out.getLines().getCharCount(), lastPattern, regExp, matchCase)
                        : out.getLines().find(0, lastPattern, regExp, matchCase);
                if (sel != null) {
                    appendMsg = NbBundle.getMessage(OutputTab.class, reversed ? "MSG_SearchFromEnd" : "MSG_SearchFromBeg");
                }
            }
            String msg;
            if (sel != null) {
                getOutputPane().unlockScroll();
                int line = out.getLines().getLineAt(sel[0]);
                ensureLineVisible(out, line);
                getOutputPane().setSelection(sel[0], sel[1]);
                int col = sel[0] - out.getLines().getLineStart(line);
                msg = NbBundle.getMessage(OutputTab.class, "MSG_Found", lastPattern, line + 1, col + 1);
                if (appendMsg != null) {
                    msg = msg + "; " + appendMsg;
                }
            } else {
                msg = NbBundle.getMessage(OutputTab.class, "MSG_NotFound", lastPattern);
            }
            StatusDisplayer.getDefault().setStatusText(msg);
            return sel != null;
        }
        return false;
    }

    /**
     * Ensure that a line is visible (not inside a collapsed fold). If a change
     * in the lines object is needed, fire immediately.
     */
    private void ensureLineVisible(OutWriter out, int line) {
        if (!out.getLines().isVisible(line)) {
            out.getLines().showFoldsForLine(line);
            if (out.getLines() instanceof ActionListener) {
                ((ActionListener) out.getLines()).actionPerformed(null);
            }
        }
    }

    /**
     * Holds the last written to directory for the save as file chooser.
     */
    private static String lastDir = null;

    /**
     * Invokes a file dialog and if a file is chosen, saves the output to that file.
     */
    void saveAs() {
        OutWriter out = getOut();
        if (out == null) {
            return;
        }
        File f = showFileChooser(this);
        if (f != null) {
            try {
                synchronized (out) {
                    out.getLines().saveAs(f.getPath());
                }
            } catch (IOException ioe) {
                NotifyDescriptor notifyDesc = new NotifyDescriptor(
                        NbBundle.getMessage(OutputTab.class, "MSG_SaveAsFailed", f.getPath()),
                        NbBundle.getMessage(OutputTab.class, "LBL_SaveAsFailedTitle"),
                        NotifyDescriptor.DEFAULT_OPTION,
                        NotifyDescriptor.ERROR_MESSAGE,
                        new Object[]{NotifyDescriptor.OK_OPTION},
                        NotifyDescriptor.OK_OPTION);

                DialogDisplayer.getDefault().notify(notifyDesc);
            }
        }
    }

    /**
     * Shows a file dialog and an overwrite dialog if the file exists, returning
     * null if the user chooses not to overwrite.  Will use an AWT FileDialog for
     * Aqua, per Apple UI guidelines.
     *
     * @param owner A parent component for the dialog - the top level ancestor will
     *        actually be used so positioning is correct
     * @return A file to write to
     */
    private static File showFileChooser(JComponent owner) {
        File f = null;
        String dlgTtl = NbBundle.getMessage(Controller.class, "TITLE_SAVE_DLG"); //NOI18N

        boolean isAqua = "Aqua".equals(UIManager.getLookAndFeel().getID()); //NOI18N

        if (isAqua) {
            //Apple UI guidelines recommend against ever using JFileChooser
            Container frameOrDialog = owner.getTopLevelAncestor();
            FileDialog fd;
            if (frameOrDialog instanceof Frame) {
                fd = new FileDialog((Frame) frameOrDialog, dlgTtl, FileDialog.SAVE);
            } else {
                fd = new FileDialog((Dialog) frameOrDialog, dlgTtl, FileDialog.SAVE);
            }
            if (lastDir != null && new File(lastDir).exists()) {
                fd.setDirectory(lastDir);
            }
            fd.setModal(true);
            fd.setVisible(true);
            if (fd.getFile() != null && fd.getDirectory() != null) {
                String s = fd.getDirectory() + fd.getFile();
                f = new File(s);
                if (f.exists() && f.isDirectory()) {
                    f = null;
                }
            }
        } else {
            JFileChooser jfc = new JFileChooser();
            if (lastDir != null && new File(lastDir).exists()) {
                File dir = new File(lastDir);
                if (dir.exists()) {
                    jfc.setCurrentDirectory(dir);
                }
            }
            jfc.setName(dlgTtl);
            jfc.setDialogTitle(dlgTtl);

            if (jfc.showSaveDialog(owner.getTopLevelAncestor()) == JFileChooser.APPROVE_OPTION) {
                f = jfc.getSelectedFile();
            }
        }

        if (f != null && f.exists() && !isAqua) { //Aqua's file dialog takes care of this
            String msg = NbBundle.getMessage(Controller.class,
                    "FMT_FILE_EXISTS", new Object[]{f.getName()}); //NOI18N
            String title = NbBundle.getMessage(Controller.class,
                    "TITLE_FILE_EXISTS"); //NOI18N
            if (JOptionPane.showConfirmDialog(owner.getTopLevelAncestor(), msg, title,
                    JOptionPane.OK_CANCEL_OPTION) != JOptionPane.OK_OPTION) {
                f = null;
            }
        }
        if (f != null) {
            lastDir = f.getParent();
        }
        return f;
    }

    /**
     * Called when a line is clicked - if an output listener is listening on that
     * line, it will be sent <code>outputLineAction</code>.
     */
    private void openHyperlink() {
        OutWriter out = getOut();
        if (out != null) {
            int pos = getOutputPane().getCaretPos();
            int[] range = new int[2];
            OutputListener l = out.getLines().getListener(pos, range);
            if (l != null) {
                ignoreCaretChanges = true;
                getOutputPane().sendCaretToPos(range[0], range[1], true);
                ignoreCaretChanges = false;
                ControllerOutputEvent coe = new ControllerOutputEvent(io, out.getLines().getLineAt(pos));
                l.outputLineAction(coe);
            }
        }
    }

    /**
     * Post the output window's popup menu
     *
     * @param p The point clicked
     * @param src The source of the click event
     */
    @NbBundle.Messages({"STATUS_Initializing=Output Window is Initializing"})
    void postPopupMenu(Point p, Component src) {
        if (!actionsLoaded) {
            StatusDisplayer.getDefault().setStatusText(
                    Bundle.STATUS_Initializing());
            return;
        }
        JPopupMenu popup = new JPopupMenu();
        Action[] a = getToolbarActions();
        if (a.length > 0) {
            boolean added = false;
            for (int i = 0; i < a.length; i++) {
                if (a[i].getValue(Action.NAME) != null) {
                    // add the proxy that doesn't show icons #67451
                    popup.add(new ProxyAction(a[i]));
                    added = true;
                }
            }
            if (added) {
                popup.addSeparator();
            }
        }

        List<TabAction> activeActions = new ArrayList<TabAction>(popupItems.length);
        for (int i = 0; i < popupItems.length; i++) {
            if (popupItems[i] == null) {
                popup.addSeparator();
            } else {
                TabAction ta = action(popupItems[i]);
                if (popupItems[i] == ACTION.WRAP) {
                    JCheckBoxMenuItem item = new JCheckBoxMenuItem(ta);
                    item.setSelected(getOutputPane().isWrapped());
                    activeActions.add(ta);
                    popup.add(item);
                } else if (popupItems[i] == ACTION.FILTER) {
                    JCheckBoxMenuItem item = new JCheckBoxMenuItem(ta);
                    item.setSelected(origPane != null);
                    activeActions.add(ta);
                    popup.add(item);
                } else {
                    if ((popupItems[i] == ACTION.CLOSE
                            && !io.getIOContainer().isCloseable(this))) {
                        continue;
                    }
                    JMenuItem item = popup.add(ta);
                    activeActions.add(ta);
                    if (popupItems[i] == ACTION.FIND) {
                        item.setMnemonic(KeyEvent.VK_F);
                    }
                }
            }
        }
        addFoldingActionsToPopUpMenu(popup, activeActions);
        // hack to remove the esc keybinding when doing popup..
        KeyStroke esc = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
        JComponent c = getOutputPane().getTextView();
        Object escHandle = c.getInputMap().get(esc);
        c.getInputMap().remove(esc);
        getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).remove(esc);

        popup.addPopupMenuListener(new PMListener(activeActions, escHandle));
        popup.show(src, p.x, p.y);

    }

    private void addFoldingActionsToPopUpMenu(JPopupMenu menu,
            List<TabAction> activeActions) {
        JMenu submenu = new JMenu(NbBundle.getMessage(
                OutputTab.class, "LBL_OutputFolds"));                   //NOI18N
        for (ACTION a : popUpFoldItems) {
            if (a == null) {
                submenu.addSeparator();
            } else {
                TabAction ta = action(a);
                activeActions.add(ta);
                submenu.add(new JMenuItem(ta));
            }
        }
        menu.addSeparator();
        menu.add(submenu);
    }

    void updateActions() {
        if (!actionsLoaded) {
            return;
        }
        OutputPane pane = (OutputPane) getOutputPane();
        int len = pane.getLength();
        boolean enable = len > 0;
        OutWriter out = getOut();
        action(SAVEAS).setEnabled(enable);
        action(SELECT_ALL).setEnabled(enable);
        action(COPY).setEnabled(pane.hasSelection());
        boolean hasErrors = out == null ? false : out.getLines().hasListeners();
        action(NEXT_ERROR).setEnabled(hasErrors);
        action(PREV_ERROR).setEnabled(hasErrors);
    }

    FilteredOutput filtOut;
    AbstractOutputPane origPane;

    private void setFilter(String pattern, boolean regExp, boolean matchCase) {
        if (pattern == null) {
            assert origPane != null;
            setOutputPane(origPane);
            origPane = null;
            filtOut.dispose();
            filtOut = null;
        } else {
            assert origPane == null;
            origPane = getOutputPane();
            filtOut = new FilteredOutput(pattern, regExp, matchCase);
            setOutputPane(filtOut.getPane());
            try {
                waitCursor(true);
                filtOut.readFrom(outWriter);
                installKBActions();
            } finally {
                waitCursor(false);
            }
        }
        validate();
        getOutputPane().repaint();
        requestFocus();
    }

    private void waitCursor(boolean enable) {
        RootPaneContainer root = ((RootPaneContainer) getTopLevelAncestor());
        Cursor cursor = Cursor.getPredefinedCursor(enable ? Cursor.WAIT_CURSOR : Cursor.DEFAULT_CURSOR);
        root.getGlassPane().setCursor(cursor);
        root.getGlassPane().setVisible(enable);
    }

    OutWriter getOut() {
        return origPane != null ? filtOut.getWriter() : outWriter;
    }

    private void disableHtmlName() {
        Controller.getDefault().removeFromUpdater(this);
        String escaped;
        try {
            escaped = XMLUtil.toAttributeValue(io.getName() + " ");
        } catch (CharConversionException e) {
            escaped = io.getName() + " ";
        }
        //#88204 apostophes are escaped in xm but not html
        io.getIOContainer().setTitle(this, escaped.replace("&apos;", "'"));
    }

    private void initOptionsListener() {
        optionsListener = new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                Lines lines = getDocumentLines();
                if (lines != null) {
                    String pn = evt.getPropertyName();
                    OutputOptions opts = io.getOptions();
                    updateOptionsProperty(pn, lines, opts);
                    OutputTab.this.repaint();
                }
            }
        };
        this.io.getOptions().addPropertyChangeListener(
                WeakListeners.propertyChange(optionsListener, io.getOptions()));
    }

    private void updateOptionsProperty(String pn, Lines lines,
            OutputOptions opts) {

        if (OutputOptions.PROP_COLOR_STANDARD.equals(pn)) {
            lines.setDefColor(IOColors.OutputType.OUTPUT,
                    opts.getColorStandard());
            getOutputPane().getFoldingSideBar().setForeground(
                    opts.getColorStandard());
        } else if (OutputOptions.PROP_COLOR_ERROR.equals(pn)) {
            lines.setDefColor(IOColors.OutputType.ERROR,
                    opts.getColorError());
        } else if (OutputOptions.PROP_COLOR_INPUT.equals(pn)) {
            lines.setDefColor(IOColors.OutputType.INPUT,
                    opts.getColorInput());
        } else if (OutputOptions.PROP_COLOR_LINK.equals(pn)) {
            lines.setDefColor(IOColors.OutputType.HYPERLINK,
                    opts.getColorLink());
        } else if (OutputOptions.PROP_COLOR_LINK_IMPORTANT.equals(pn)) {
            lines.setDefColor(IOColors.OutputType.HYPERLINK_IMPORTANT,
                    opts.getColorLinkImportant());
        } else if (OutputOptions.PROP_COLOR_BACKGROUND.equals(pn)) {
            Color bg = opts.getColorBackground();
            setTextViewBackground(getOutputPane().getTextView(), bg);
        } else if (OutputOptions.PROP_FONT.equals(pn)) {
            if (!getOutputPane().isWrapped()) {
                getOutputPane().setViewFont(opts.getFont());
            }
        } else if (OutputOptions.PROP_FONT_SIZE_WRAP.equals(pn)) {
            if (getOutputPane().isWrapped()) {
                getOutputPane().setViewFont(opts.getFontForWrappedMode());
            }
        }
    }

    private void loadAndInitActions() {
        RP.post(new Runnable() {
            @Override
            public void run() {
                createActions();
                EventQueue.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        installKBActions();
                        getActionMap().put("jumpPrev", //NOI18N
                                action(PREV_ERROR));
                        getActionMap().put("jumpNext", //NOI18N
                                action(NEXT_ERROR));
                        getActionMap().put(FindAction.class.getName(),
                                action(FIND));
                        getActionMap().put(
                                javax.swing.text.DefaultEditorKit.copyAction,
                                action(COPY));
                        actionsLoaded = true;
                        updateActions();
                        setInputVisible(isInputVisible()); // update action
                    }
                });
            }
        });
    }

    static enum ACTION { COPY, WRAP, SAVEAS, CLOSE, NEXT_ERROR, PREV_ERROR,
                         SELECT_ALL, FIND, FIND_NEXT, NAVTOLINE, POSTMENU,
                         FIND_PREVIOUS, CLEAR, NEXTTAB, PREVTAB, LARGER_FONT,
                         SMALLER_FONT, SETTINGS, FILTER, PASTE, COLLAPSE_FOLD,
                         EXPAND_FOLD, COLLAPSE_ALL, EXPAND_ALL, COLLAPSE_TREE,
                         EXPAND_TREE}

    private static final ACTION[] popupItems = new ACTION[] {
        COPY, PASTE, null, FIND, FIND_NEXT, FIND_PREVIOUS, FILTER, null,
        WRAP, LARGER_FONT, SMALLER_FONT, SETTINGS, null,
        SAVEAS, CLEAR, CLOSE,
    };

    private static final ACTION[] popUpFoldItems = new ACTION[]{
        COLLAPSE_FOLD, EXPAND_FOLD, null,
        COLLAPSE_ALL, EXPAND_ALL, null,
        COLLAPSE_TREE, EXPAND_TREE
    };

    private static final ACTION[] actionsToInstall = new ACTION[] {
            COPY, SELECT_ALL, FIND, FIND_NEXT, FIND_PREVIOUS, WRAP, LARGER_FONT,
            SMALLER_FONT, SAVEAS, CLOSE, COPY, NAVTOLINE, POSTMENU, CLEAR, FILTER,
            COLLAPSE_FOLD, EXPAND_FOLD, COLLAPSE_ALL, EXPAND_ALL, COLLAPSE_TREE,
            EXPAND_TREE
    };

    private final Map<ACTION, TabAction> actions = new EnumMap<ACTION, TabAction>(ACTION.class);;

    private void createActions() {
        KeyStrokeUtils.refreshActionCache();
        for (ACTION a : ACTION.values()) {
            TabAction action;
            switch(a) {
                case COPY:
                case PASTE:
                case WRAP:
                case SAVEAS:
                case CLOSE:
                case NEXT_ERROR:
                case PREV_ERROR:
                case SELECT_ALL:
                case FIND:
                case FIND_NEXT:
                case FIND_PREVIOUS:
                case FILTER:
                case LARGER_FONT:
                case SMALLER_FONT:
                case SETTINGS:
                case CLEAR:
                case COLLAPSE_FOLD:
                case EXPAND_FOLD:
                case COLLAPSE_ALL:
                case EXPAND_ALL:
                case COLLAPSE_TREE:
                case EXPAND_TREE:
                    action = new TabAction(a, "ACTION_"+a.name());
                    break;
                case NAVTOLINE:
                    action = new TabAction(a, "navToLine", //NOI18N
                                KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));
                    break;
                case POSTMENU:
                    action = new TabAction(a, "postMenu", //NOI18N
                                KeyStroke.getKeyStroke(KeyEvent.VK_F10, KeyEvent.SHIFT_DOWN_MASK));
                    break;
                case NEXTTAB:
                    action = new TabAction(a, "NextViewAction", //NOI18N
                                (KeyStroke) null);
                    break;
                case PREVTAB:
                    action = new TabAction(a, "PreviousViewAction", //NOI18N
                                (KeyStroke) null);
                    break;
                default:
                    throw new IllegalStateException("Unhandled action "+a);
            }
            actions.put(a, action);
        }
    }

    /**
     * A stateless action which will find the owning OutputTab's controller and call
     * actionPerformed with its ID as an argument.
     */
    class TabAction extends AbstractAction {

        private ACTION action;

        /**
         * Create a ControllerAction with the specified action ID (constants defined in Controller),
         * using the specified bundle key.  Expects the following contents in the bundle:
         * <ul>
         * <li>A name for the action matching the passed key</li>
         * <li>An accelerator for the action matching [key].accel</li>
         * </ul>
         * @param id An action ID
         * @param bundleKey A key for the bundle associated with the Controller class
         * @see org.openide.util.Utilities#stringToKey
         */
        TabAction(ACTION action, String bundleKey) {
            if (bundleKey != null) {
                String name = NbBundle.getMessage(OutputTab.class, bundleKey);
                List<KeyStroke[]> accels = getAcceleratorsFor(action);
                this.action = action;
                putValue(NAME, name);
                if (accels != null && accels.size() > 0) {
                    List<KeyStroke> l = new ArrayList<KeyStroke>(accels.size());
                    for (KeyStroke[] ks : accels) {
                        if (ks.length == 1) { // ignore multi-key accelerators
                            l.add(ks[0]);
                        }
                    }
                    if (l.size() > 0) {
                        putValue(ACCELERATORS_KEY,
                                l.toArray(new KeyStroke[l.size()]));
                        putValue(ACCELERATOR_KEY, l.get(0));
                    }
                }
            }
        }

        /**
         * Create a ControllerAction with the specified ID, name and keystroke.  Actions created
         * using this constructor will not be added to the popup menu of the component.
         *
         * @param id The ID
         * @param name A programmatic name for the item
         * @param stroke An accelerator keystroke
         */
        TabAction(ACTION action, String name, KeyStroke stroke) {
            this.action = action;
            putValue(NAME, name);
            putValue(ACCELERATOR_KEY, stroke);
        }

        void clearListeners() {
            PropertyChangeListener[] l = changeSupport.getPropertyChangeListeners();
            for (int i = 0; i < l.length; i++) {
                removePropertyChangeListener(l[i]);
            }
        }

        /**
         * Get a keyboard accelerator from the resource bundle, with special handling
         * for the mac keyboard layout.
         *
         * @param action Action to get accelerator for.
         * @return A keystroke
         */
        private List<KeyStroke[]> getAcceleratorsFor(ACTION action) {
            switch (action) {
                case COPY:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "copy-to-clipboard", null);                 //NOI18N
                case PASTE:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "paste-from-clipboard", null);              //NOI18N
                case SAVEAS:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.SAVE_AS_ACTION_ID, null);
                case CLOSE:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.CLOSE_ACTION_ID, null);
                case NEXT_ERROR:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "next-error", null);                        //NOI18N
                case PREV_ERROR:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "previous-error", null);                    //NOI18N
                case SELECT_ALL:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "select-all", null);                        //NOI18N
                case FIND:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "org.openide.actions.FindAction", null);    //NOI18N
                case FIND_NEXT:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "find-next", null);                         //NOI18N
                case FIND_PREVIOUS:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "find-previous", null);                     //NOI18N
                case FILTER:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.FILTER_ACTION_ID, null);
                case LARGER_FONT:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.LARGER_FONT_ACTION_ID, null);
                case SMALLER_FONT:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.SMALLER_FONT_ACTION_ID, null);
                case SETTINGS:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.OUTPUT_SETTINGS_ACTION_ID, null);
                case CLEAR:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.CLEAR_ACTION_ID, null);
                case WRAP:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            OutputKeymapManager.WRAP_ACTION_ID, null);
                case COLLAPSE_FOLD:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "collapse-fold", null);                     //NOI18N
                case EXPAND_FOLD:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "expand-fold", null);                       //NOI18N
                case COLLAPSE_ALL:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "collapse-all-folds", null);                //NOI18N
                case EXPAND_ALL:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "expand-all-folds", null);                  //NOI18N
                case COLLAPSE_TREE:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "collapse-fold-tree", null);                //NOI18N
                case EXPAND_TREE:
                    return KeyStrokeUtils.getKeyStrokesForAction(
                            "expand-fold-tree", null);                  //NOI18N
                default:
                    return null;
            }
        }

        public ACTION getAction() {
            return action;
        }

        @Override
        public boolean isEnabled() {
            if (getIO().isClosed()) {
                // Cached action for an already closed tab.
                // Try to find the appropriate action for a new active tab...
                JComponent selected = getIO().getIOContainer().getSelected();
                if (OutputTab.this != selected && selected instanceof OutputTab) {
                    OutputTab tab = (OutputTab) selected;
                    Action a = tab.action(action);
                    if (a != null) {
                        return a.isEnabled();
                    }
                }
                return false;
            }
            return super.isEnabled();
        }

        public void actionPerformed(ActionEvent e) {
            if (getIO().isClosed()) {
                // Cached action for an already closed tab.
                // Try to find the appropriate action for a new active tab...
                JComponent selected = getIO().getIOContainer().getSelected();
                if (OutputTab.this != selected && selected instanceof OutputTab) {
                    OutputTab tab = (OutputTab) selected;
                    Action a = tab.action(action);
                    if (a != null) {
                        a.actionPerformed(e);
                    }
                }
                return ;
            }
            switch (getAction()) {
                case COPY:
                    getOutputPane().copy();
                    break;
                case PASTE:
                    getOutputPane().paste();
                    break;
                case WRAP:
                    boolean wrapped = getOutputPane().isWrapped();
                    getOutputPane().setWrapped(!wrapped);
                    break;
                case SAVEAS:
                    saveAs();
                    break;
                case CLOSE:
                    io.getIOContainer().remove(OutputTab.this);
                    break;
                case NEXT_ERROR:
                    sendCaretToError(false);
                    break;
                case PREV_ERROR:
                    sendCaretToError(true);
                    break;
                case SELECT_ALL:
                    getOutputPane().selectAll();
                    break;
                case FIND:
                     {
                        String pattern = getFindDlgResult(getOutputPane().getSelectedText(), "LBL_Find_Title", "LBL_Find_What", "BTN_Find"); //NOI18N
                        if (pattern != null && find(false)) {
                            Action findNext = action(FIND_NEXT);
                            Action findPrev = action(FIND_PREVIOUS);
                            if (findNext != null) {
                                findNext.setEnabled(true);
                            }
                            if (findPrev != null) {
                                findPrev.setEnabled(true);
                            }
                            requestFocus();
                        }
                    }
                    break;
                case FIND_NEXT:
                    find(false);
                    break;
                case FIND_PREVIOUS:
                    find(true);
                    break;
                case NAVTOLINE:
                    openHyperlink();
                    break;
                case POSTMENU:
                    postPopupMenu(new Point(0, 0), OutputTab.this);
                    break;
                case CLEAR:
                    NbWriter writer = io.writer();
                    if (writer != null) {
                        try {
                            boolean vis = isInputVisible();
                            boolean closed = io.isStreamClosed();
                            writer.reset();
                            setInputVisible(vis);
                            io.setStreamClosed(closed);
                        } catch (IOException ioe) {
                            Exceptions.printStackTrace(ioe);
                        }
                    }
                    break;
                case SMALLER_FONT:
                    Controller.getDefault().changeFontSizeBy(-1, getOutputPane().isWrapped());
                    break;
                case LARGER_FONT:
                    Controller.getDefault().changeFontSizeBy(1, getOutputPane().isWrapped());
                    break;
                case SETTINGS:
                    OptionsDisplayer.getDefault().open(
                            "Advanced/OutputSettings");                 //NOI18N
                    break;
                case FILTER:
                    if (origPane != null) {
                        setFilter(null, false, false);
                    } else {
                        String pattern = getFindDlgResult(getOutputPane().getSelectedText(),
                                "LBL_Filter_Title", "LBL_Filter_What", "BTN_Filter"); //NOI18N
                        if (pattern != null) {
                            setFilter(pattern, FindDialogPanel.regExp(), FindDialogPanel.matchCase());
                        }
                    }
                    break;
                case COLLAPSE_FOLD:
                    getOutputPane().collapseFold();
                    break;
                case EXPAND_FOLD:
                    getOutputPane().expandFold();
                    break;
                case COLLAPSE_ALL:
                    getOutputPane().collapseAllFolds();
                    break;
                case EXPAND_ALL:
                    getOutputPane().expandAllFolds();
                    break;
                case COLLAPSE_TREE:
                    getOutputPane().collapseFoldTree();
                    break;
                case EXPAND_TREE:
                    getOutputPane().expandFoldTree();
                    break;
                default:
                    assert false;
            }
        }
    }

    @Override
    public void setInputVisible(boolean val) {
        super.setInputVisible(val);
        Action pasteAction = action(PASTE);
        if (pasteAction != null) {
            pasteAction.setEnabled(val);
        }
    }

    private boolean validRegExp(String pattern) {
        try {
            Pattern.compile(pattern);
            return true;
        } catch (PatternSyntaxException ex) {
            JOptionPane.showMessageDialog(getTopLevelAncestor(), 
                    NbBundle.getMessage(OutputTab.class, "FMT_Invalid_RegExp", pattern),
                    NbBundle.getMessage(OutputTab.class, "LBL_Invalid_RegExp"), JOptionPane.ERROR_MESSAGE);
            return false;
        }
    }

    private String getFindDlgResult(String selection, String title, String label, String button) {
        String pattern = FindDialogPanel.getResult(selection, title, label, button); //NOI18N
        while (pattern != null && FindDialogPanel.regExp()) {
            if (validRegExp(pattern)) {
                break;
            }
            pattern = FindDialogPanel.getResult(pattern, title, label, button); //NOI18N
        }
        return pattern;
    }

    private static class ProxyAction implements Action {

        private Action orig;

        ProxyAction(Action original) {
            orig = original;
        }

        public Object getValue(String key) {
            if (Action.SMALL_ICON.equals(key)) {
                return null;
            }
            return orig.getValue(key);
        }

        public void putValue(String key, Object value) {
            orig.putValue(key, value);
        }

        public void setEnabled(boolean b) {
            orig.setEnabled(b);
        }

        public boolean isEnabled() {
            return orig.isEnabled();
        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {
            orig.addPropertyChangeListener(listener);
        }

        public void removePropertyChangeListener(PropertyChangeListener listener) {
            orig.removePropertyChangeListener(listener);
        }

        public void actionPerformed(ActionEvent e) {
            orig.actionPerformed(e);
        }
    }

    /**
     * #47166 - a disposed tab which has had its popup menu shown remains
     * referenced through PopupItems->JSeparator->PopupMenu->Invoker->OutputPane->OutputTab
     */
    private class PMListener implements PopupMenuListener {

        private List<TabAction> popupItems;
        private Object handle;

        PMListener(List<TabAction> popupItems, Object escHandle) {
            this.popupItems = popupItems;
            handle = escHandle;
        }

        public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
            JPopupMenu popup = (JPopupMenu) e.getSource();
            popup.removeAll();
            popup.setInvoker(null);
            // hack
            KeyStroke esc = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
            JComponent c = getOutputPane().getTextView();
            c.getInputMap().put(esc, handle);
            getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(esc, handle);

            //hack end
            popup.removePopupMenuListener(this);
            for (TabAction action : popupItems) {
                action.clearListeners();
            }
        }

        public void popupMenuCanceled(PopupMenuEvent e) {
            popupMenuWillBecomeInvisible(e);
        }

        public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
            //do nothing
        }
    }

    private class FilteredOutput {
        String pattern;
        OutWriter out;
        OutputPane pane;
        OutputDocument doc;
        int readCount;
        Pattern compPattern;
        boolean regExp;
        boolean matchCase;

        public FilteredOutput(String pattern, boolean regExp, boolean matchCase) {
            this.pattern = (regExp || matchCase) ? pattern : pattern.toLowerCase();
            this.regExp = regExp;
            this.matchCase = matchCase;
            out = new OutWriter();
            pane = new OutputPane(OutputTab.this);
            doc = new OutputDocument(out);
            pane.setDocument(doc);
        }

        boolean passFilter(String str) {
            if (regExp) {
                if (compPattern == null) {
                    compPattern = matchCase ? Pattern.compile(pattern) : Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
                }
                return compPattern.matcher(str).find();
            } else {
                return matchCase ? str.contains(pattern) : str.toLowerCase().contains(pattern);
            }
        }

        OutputPane getPane() {
            return pane;
        }

        OutWriter getWriter() {
            return out;
        }

        synchronized void readFrom(OutWriter orig) {
            AbstractLines lines = (AbstractLines) orig.getLines();
            // Last line is not guaranteed to be finished, see #219839.
            int lineCount = lines.getLineCount() - (orig.isClosed() ? 0 : 1);
            while (readCount < lineCount) {
                try {
                    int line = readCount++;
                    String str = lines.getLine(line);
                    if (!passFilter(str)) {
                        continue;
                    }
                    LineInfo info = lines.getExistingLineInfo(line);
                    out.print(str, info, lines.isImportantLine(line));
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }

        void dispose() {
            out.dispose();
        }
    }

    private Lines getDocumentLines() {
        OutputDocument doc = getDocument();
        return doc == null ? null : doc.getLines();
    }
}
