| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed 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 com.intellij.execution.impl; |
| |
| import com.google.common.base.CharMatcher; |
| import com.intellij.codeInsight.navigation.IncrementalSearchHandler; |
| import com.intellij.codeInsight.template.impl.editorActions.TypedActionHandlerBase; |
| import com.intellij.execution.ConsoleFolding; |
| import com.intellij.execution.ExecutionBundle; |
| import com.intellij.execution.actions.ConsoleActionsPostProcessor; |
| import com.intellij.execution.actions.EOFAction; |
| import com.intellij.execution.filters.*; |
| import com.intellij.execution.process.ProcessHandler; |
| import com.intellij.execution.ui.ConsoleView; |
| import com.intellij.execution.ui.ConsoleViewContentType; |
| import com.intellij.execution.ui.ObservableConsoleView; |
| import com.intellij.icons.AllIcons; |
| import com.intellij.ide.CommonActionsManager; |
| import com.intellij.ide.OccurenceNavigator; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.actionSystem.*; |
| import com.intellij.openapi.application.ApplicationManager; |
| import com.intellij.openapi.application.ModalityState; |
| import com.intellij.openapi.command.CommandProcessor; |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.editor.*; |
| import com.intellij.openapi.editor.actionSystem.*; |
| import com.intellij.openapi.editor.actions.ScrollToTheEndToolbarAction; |
| import com.intellij.openapi.editor.actions.ToggleUseSoftWrapsToolbarAction; |
| import com.intellij.openapi.editor.colors.EditorColorsScheme; |
| import com.intellij.openapi.editor.event.*; |
| import com.intellij.openapi.editor.ex.DocumentEx; |
| import com.intellij.openapi.editor.ex.EditorEx; |
| import com.intellij.openapi.editor.ex.util.EditorUtil; |
| import com.intellij.openapi.editor.highlighter.EditorHighlighter; |
| import com.intellij.openapi.editor.highlighter.HighlighterClient; |
| import com.intellij.openapi.editor.highlighter.HighlighterIterator; |
| import com.intellij.openapi.editor.impl.DocumentImpl; |
| import com.intellij.openapi.editor.impl.softwrap.SoftWrapAppliancePlaces; |
| import com.intellij.openapi.editor.markup.RangeHighlighter; |
| import com.intellij.openapi.editor.markup.TextAttributes; |
| import com.intellij.openapi.extensions.Extensions; |
| import com.intellij.openapi.fileEditor.OpenFileDescriptor; |
| import com.intellij.openapi.ide.CopyPasteManager; |
| import com.intellij.openapi.keymap.Keymap; |
| import com.intellij.openapi.keymap.KeymapManager; |
| import com.intellij.openapi.project.DumbAware; |
| import com.intellij.openapi.project.DumbAwareAction; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.*; |
| import com.intellij.openapi.util.registry.Registry; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.psi.PsiDocumentManager; |
| import com.intellij.psi.search.GlobalSearchScope; |
| import com.intellij.psi.tree.IElementType; |
| import com.intellij.ui.EditorNotificationPanel; |
| import com.intellij.ui.awt.RelativePoint; |
| import com.intellij.util.Alarm; |
| import com.intellij.util.Consumer; |
| import com.intellij.util.EditorPopupHandler; |
| import com.intellij.util.SystemProperties; |
| import com.intellij.util.text.CharArrayUtil; |
| import com.intellij.util.ui.UIUtil; |
| import gnu.trove.TIntObjectHashMap; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.awt.datatransfer.DataFlavor; |
| import java.awt.event.MouseEvent; |
| import java.io.IOException; |
| import java.util.*; |
| import java.util.List; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| |
| public class ConsoleViewImpl extends JPanel implements ConsoleView, ObservableConsoleView, DataProvider, OccurenceNavigator { |
| @NonNls private static final String CONSOLE_VIEW_POPUP_MENU = "ConsoleView.PopupMenu"; |
| private static final Logger LOG = Logger.getInstance("#com.intellij.execution.impl.ConsoleViewImpl"); |
| |
| private static final int DEFAULT_FLUSH_DELAY = SystemProperties.getIntProperty("console.flush.delay.ms", 200); |
| |
| private static final CharMatcher NEW_LINE_MATCHER = CharMatcher.anyOf("\n\r"); |
| |
| public static final Key<ConsoleViewImpl> CONSOLE_VIEW_IN_EDITOR_VIEW = Key.create("CONSOLE_VIEW_IN_EDITOR_VIEW"); |
| |
| static { |
| final EditorActionManager actionManager = EditorActionManager.getInstance(); |
| final TypedAction typedAction = actionManager.getTypedAction(); |
| typedAction.setupHandler(new MyTypedHandler(typedAction.getHandler())); |
| } |
| |
| |
| private final CommandLineFolding myCommandLineFolding = new CommandLineFolding(); |
| |
| private final DisposedPsiManagerCheck myPsiDisposedCheck; |
| private final boolean myIsViewer; |
| |
| private ConsoleState myState; |
| |
| private final Alarm mySpareTimeAlarm = new Alarm(this); |
| @Nullable |
| private final Alarm myHeavyAlarm; |
| private int myHeavyUpdateTicket; |
| |
| private final Collection<ChangeListener> myListeners = new CopyOnWriteArraySet<ChangeListener>(); |
| private final List<AnAction> customActions = new ArrayList<AnAction>(); |
| private final ConsoleBuffer myBuffer = new ConsoleBuffer(); |
| private boolean myUpdateFoldingsEnabled = true; |
| private EditorHyperlinkSupport myHyperlinks; |
| private MyDiffContainer myJLayeredPane; |
| private JPanel myMainPanel; |
| private final Runnable myFinishProgress; |
| private boolean myAllowHeavyFilters = false; |
| private static final int myFlushDelay = DEFAULT_FLUSH_DELAY; |
| |
| private boolean myTooMuchOfOutput; |
| private boolean myInDocumentUpdate; |
| |
| // If true, then a document is being cleared right now. |
| // Should be accessed in EDT only. |
| @SuppressWarnings("FieldAccessedSynchronizedAndUnsynchronized") |
| private boolean myDocumentClearing; |
| private int myLastAddedTextLength; |
| private int consoleTooMuchTextBufferRatio; |
| |
| public Editor getEditor() { |
| return myEditor; |
| } |
| |
| public EditorHyperlinkSupport getHyperlinks() { |
| return myHyperlinks; |
| } |
| |
| public void scrollToEnd() { |
| if (myEditor == null) return; |
| myEditor.getCaretModel().moveToOffset(myEditor.getDocument().getTextLength()); |
| } |
| |
| public void foldImmediately() { |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| if (!myFlushAlarm.isEmpty()) { |
| cancelAllFlushRequests(); |
| new MyFlushRunnable().run(); |
| } |
| |
| myFoldingAlarm.cancelAllRequests(); |
| |
| myPendingFoldRegions.clear(); |
| final FoldingModel model = myEditor.getFoldingModel(); |
| model.runBatchFoldingOperation(new Runnable() { |
| @Override |
| public void run() { |
| for (FoldRegion region : model.getAllFoldRegions()) { |
| model.removeFoldRegion(region); |
| } |
| } |
| }); |
| myFolding.clear(); |
| |
| updateFoldings(0, myEditor.getDocument().getLineCount() - 1, true); |
| } |
| |
| static class TokenInfo { |
| final ConsoleViewContentType contentType; |
| int startOffset; |
| int endOffset; |
| private final TextAttributes attributes; |
| |
| TokenInfo(final ConsoleViewContentType contentType, final int startOffset, final int endOffset) { |
| this.contentType = contentType; |
| this.startOffset = startOffset; |
| this.endOffset = endOffset; |
| attributes = contentType.getAttributes(); |
| } |
| |
| public int getLength() { |
| return endOffset - startOffset; |
| } |
| |
| @Override |
| public String toString() { |
| return contentType + "[" + startOffset + ";" + endOffset + "]"; |
| } |
| |
| @Nullable |
| public HyperlinkInfo getHyperlinkInfo() { |
| return null; |
| } |
| } |
| |
| static class HyperlinkTokenInfo extends TokenInfo { |
| private final HyperlinkInfo myHyperlinkInfo; |
| |
| HyperlinkTokenInfo(final ConsoleViewContentType contentType, final int startOffset, final int endOffset, HyperlinkInfo hyperlinkInfo) { |
| super(contentType, startOffset, endOffset); |
| myHyperlinkInfo = hyperlinkInfo; |
| } |
| |
| @Override |
| public HyperlinkInfo getHyperlinkInfo() { |
| return myHyperlinkInfo; |
| } |
| } |
| |
| private final Project myProject; |
| |
| private boolean myOutputPaused; |
| |
| private EditorEx myEditor; |
| |
| private final Object LOCK = new Object(); |
| |
| /** |
| * Holds number of symbols managed by the current console. |
| * <p/> |
| * Total number is assembled as a sum of symbols that are already pushed to the document and number of deferred symbols that |
| * are awaiting to be pushed to the document. |
| */ |
| private int myContentSize; |
| |
| /** |
| * Holds information about lexical division by offsets of the text already pushed to document. |
| * <p/> |
| * Target offsets are anchored to the document here. |
| */ |
| private final List<TokenInfo> myTokens = new ArrayList<TokenInfo>(); |
| |
| private final TIntObjectHashMap<ConsoleFolding> myFolding = new TIntObjectHashMap<ConsoleFolding>(); |
| |
| private String myHelpId; |
| |
| private final Alarm myFlushUserInputAlarm = new Alarm(Alarm.ThreadToUse.POOLED_THREAD, this); |
| private final Alarm myFlushAlarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD, this); |
| |
| private final Set<MyFlushRunnable> myCurrentRequests = new HashSet<MyFlushRunnable>(); |
| |
| protected final CompositeFilter myFilters; |
| |
| @Nullable private final InputFilter myInputMessageFilter; |
| |
| private final Alarm myFoldingAlarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD, this); |
| private final List<FoldRegion> myPendingFoldRegions = new ArrayList<FoldRegion>(); |
| |
| public ConsoleViewImpl(final Project project, boolean viewer) { |
| this(project, GlobalSearchScope.allScope(project), viewer, true); |
| } |
| |
| public ConsoleViewImpl(@NotNull final Project project, |
| @NotNull GlobalSearchScope searchScope, |
| boolean viewer, |
| boolean usePredefinedMessageFilter) { |
| this(project, searchScope, viewer, |
| new ConsoleState.NotStartedStated() { |
| @Override |
| public ConsoleState attachTo(ConsoleViewImpl console, ProcessHandler processHandler) { |
| return new ConsoleViewRunningState(console, processHandler, this, true, true); |
| } |
| }, |
| usePredefinedMessageFilter); |
| } |
| |
| protected ConsoleViewImpl(@NotNull final Project project, |
| @NotNull GlobalSearchScope searchScope, |
| boolean viewer, |
| @NotNull final ConsoleState initialState, |
| boolean usePredefinedMessageFilter) |
| { |
| super(new BorderLayout()); |
| myIsViewer = viewer; |
| myState = initialState; |
| myPsiDisposedCheck = new DisposedPsiManagerCheck(project); |
| myProject = project; |
| |
| myFilters = new CompositeFilter(project); |
| if (usePredefinedMessageFilter) { |
| for (ConsoleFilterProvider eachProvider : Extensions.getExtensions(ConsoleFilterProvider.FILTER_PROVIDERS)) { |
| Filter[] filters; |
| if (eachProvider instanceof ConsoleDependentFilterProvider) { |
| filters = ((ConsoleDependentFilterProvider)eachProvider).getDefaultFilters(this, project, searchScope); |
| } |
| else if (eachProvider instanceof ConsoleFilterProviderEx) { |
| filters = ((ConsoleFilterProviderEx)eachProvider).getDefaultFilters(project, searchScope); |
| } |
| else { |
| filters = eachProvider.getDefaultFilters(project); |
| } |
| for (Filter filter : filters) { |
| myFilters.addFilter(filter); |
| } |
| } |
| } |
| myFilters.setForceUseAllFilters(true); |
| myHeavyUpdateTicket = 0; |
| myHeavyAlarm = myFilters.isAnyHeavy() ? new Alarm(Alarm.ThreadToUse.SHARED_THREAD, this) : null; |
| |
| |
| ConsoleInputFilterProvider[] inputFilters = Extensions.getExtensions(ConsoleInputFilterProvider.INPUT_FILTER_PROVIDERS); |
| if (inputFilters.length > 0) { |
| CompositeInputFilter compositeInputFilter = new CompositeInputFilter(project); |
| myInputMessageFilter = compositeInputFilter; |
| for (ConsoleInputFilterProvider eachProvider : inputFilters) { |
| InputFilter[] filters = eachProvider.getDefaultFilters(project); |
| for (final InputFilter filter : filters) { |
| compositeInputFilter.addFilter(new InputFilter() { |
| boolean isBroken; |
| |
| @Nullable |
| @Override |
| public List<Pair<String, ConsoleViewContentType>> applyFilter(String text, ConsoleViewContentType contentType) { |
| if (!isBroken) { |
| try { |
| return filter.applyFilter(text, contentType); |
| } |
| catch (Throwable e) { |
| isBroken = true; |
| LOG.error(e); |
| } |
| } |
| return null; |
| } |
| }); |
| } |
| } |
| } |
| else { |
| myInputMessageFilter = null; |
| } |
| |
| myFinishProgress = new Runnable() { |
| @Override |
| public void run() { |
| myJLayeredPane.finishUpdating(); |
| } |
| }; |
| consoleTooMuchTextBufferRatio = Registry.intValue("console.too.much.text.buffer.ratio"); |
| } |
| |
| @Override |
| public void attachToProcess(final ProcessHandler processHandler) { |
| myState = myState.attachTo(this, processHandler); |
| } |
| |
| @Override |
| public void clear() { |
| if (myEditor == null) return; |
| synchronized (LOCK) { |
| // real document content will be cleared on next flush; |
| myContentSize = 0; |
| myBuffer.clear(); |
| myFolding.clear(); |
| } |
| if (myFlushAlarm.isDisposed()) return; |
| cancelAllFlushRequests(); |
| addFlushRequest(new MyClearRunnable()); |
| cancelHeavyAlarm(); |
| } |
| |
| @Override |
| public void scrollTo(final int offset) { |
| if (myEditor == null || myFlushAlarm.isDisposed()) return; |
| class ScrollRunnable extends MyFlushRunnable { |
| private final int myOffset = offset; |
| |
| @Override |
| public void doRun() { |
| flushDeferredText(); |
| if (myEditor == null) return; |
| int moveOffset = Math.min(offset, myEditor.getDocument().getTextLength()); |
| if (myBuffer.isUseCyclicBuffer() && moveOffset >= myEditor.getDocument().getTextLength()) { |
| moveOffset = 0; |
| } |
| myEditor.getCaretModel().moveToOffset(moveOffset); |
| myEditor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return super.equals(o) && myOffset == ((ScrollRunnable)o).myOffset; |
| } |
| } |
| addFlushRequest(new ScrollRunnable()); |
| } |
| |
| public void requestScrollingToEnd() { |
| if (myEditor == null || myFlushAlarm.isDisposed()) { |
| return; |
| } |
| |
| addFlushRequest(new MyFlushRunnable() { |
| @Override |
| public void doRun() { |
| flushDeferredText(); |
| if (myEditor == null || myFlushAlarm.isDisposed()) { |
| return; |
| } |
| |
| myEditor.getCaretModel().moveToOffset(myEditor.getDocument().getTextLength()); |
| myEditor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); |
| } |
| }); |
| } |
| |
| private void addFlushRequest(MyFlushRunnable scrollRunnable) { |
| addFlushRequest(scrollRunnable, 0); |
| } |
| |
| private void addFlushRequest(MyFlushRunnable flushRunnable, final int millis) { |
| synchronized (myCurrentRequests) { |
| if (!myFlushAlarm.isDisposed() && myCurrentRequests.add(flushRunnable)) { |
| myFlushAlarm.addRequest(flushRunnable, millis, getStateForUpdate()); |
| } |
| } |
| } |
| |
| |
| private static void assertIsDispatchThread() { |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| } |
| |
| @Override |
| public void setOutputPaused(final boolean value) { |
| myOutputPaused = value; |
| if (!value) { |
| requestFlushImmediately(); |
| } |
| } |
| |
| @Override |
| public boolean isOutputPaused() { |
| return myOutputPaused; |
| } |
| |
| @Override |
| public boolean hasDeferredOutput() { |
| synchronized (LOCK) { |
| return myBuffer.getLength() > 0; |
| } |
| } |
| |
| @Override |
| public void performWhenNoDeferredOutput(final Runnable runnable) { |
| //Q: implement in another way without timer? |
| if (!hasDeferredOutput()) { |
| runnable.run(); |
| } |
| else { |
| performLaterWhenNoDeferredOutput(runnable); |
| } |
| } |
| |
| private void performLaterWhenNoDeferredOutput(final Runnable runnable) { |
| if (mySpareTimeAlarm.isDisposed()) return; |
| mySpareTimeAlarm.addRequest( |
| new Runnable() { |
| @Override |
| public void run() { |
| performWhenNoDeferredOutput(runnable); |
| } |
| }, |
| 100, |
| ModalityState.stateForComponent(myJLayeredPane) |
| ); |
| } |
| |
| @Override |
| public JComponent getComponent() { |
| if (myMainPanel == null) { |
| myMainPanel = new JPanel(new BorderLayout()); |
| myJLayeredPane = new MyDiffContainer(myMainPanel, myFilters.getUpdateMessage()); |
| Disposer.register(this, myJLayeredPane); |
| add(myJLayeredPane, BorderLayout.CENTER); |
| } |
| |
| if (myEditor == null) { |
| myEditor = createEditor(); |
| registerConsoleEditorActions(); |
| myEditor.getScrollPane().setBorder(null); |
| myHyperlinks = new EditorHyperlinkSupport(myEditor, myProject); |
| requestFlushImmediately(); |
| myMainPanel.add(createCenterComponent(), BorderLayout.CENTER); |
| myEditor.getScrollingModel().addVisibleAreaListener(new VisibleAreaListener() { |
| @Override |
| public void visibleAreaChanged(VisibleAreaEvent e) { |
| // There is a possible case that the console text is populated while the console is not shown (e.g. we're debugging and |
| // 'Debugger' tab is active while 'Console' is not). It's also possible that newly added text contains long lines that |
| // are soft wrapped. We want to update viewport position then when the console becomes visible. |
| final Rectangle oldRectangle = e.getOldRectangle(); |
| if (oldRectangle == null) { |
| return; |
| } |
| |
| Editor myEditor = e.getEditor(); |
| if (oldRectangle.height <= 0 && e.getNewRectangle().height > 0 && myEditor.getSoftWrapModel().isSoftWrappingEnabled() |
| && myEditor.getCaretModel().getOffset() == myEditor.getDocument().getTextLength()) { |
| EditorUtil.scrollToTheEnd(myEditor); |
| } |
| } |
| }); |
| } |
| return this; |
| } |
| |
| protected JComponent createCenterComponent() { |
| return myEditor.getComponent(); |
| } |
| |
| @Override |
| public void dispose() { |
| myState = myState.dispose(); |
| if (myEditor != null) { |
| cancelAllFlushRequests(); |
| mySpareTimeAlarm.cancelAllRequests(); |
| disposeEditor(); |
| synchronized (LOCK) { |
| myBuffer.clear(); |
| } |
| myEditor = null; |
| myHyperlinks = null; |
| } |
| } |
| |
| private void cancelAllFlushRequests() { |
| synchronized (myCurrentRequests) { |
| for (MyFlushRunnable request : myCurrentRequests) { |
| request.invalidate(); |
| } |
| myCurrentRequests.clear(); |
| myFlushAlarm.cancelAllRequests(); |
| } |
| } |
| |
| protected void disposeEditor() { |
| UIUtil.invokeAndWaitIfNeeded(new Runnable() { |
| @Override |
| public void run() { |
| if (!myEditor.isDisposed()) { |
| EditorFactory.getInstance().releaseEditor(myEditor); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void print(@NotNull String s, @NotNull ConsoleViewContentType contentType) { |
| if (myInputMessageFilter == null) { |
| printHyperlink(s, contentType, null); |
| return; |
| } |
| |
| List<Pair<String, ConsoleViewContentType>> result = myInputMessageFilter.applyFilter(s, contentType); |
| if (result == null) { |
| printHyperlink(s, contentType, null); |
| } |
| else { |
| for (Pair<String, ConsoleViewContentType> pair : result) { |
| if (pair.first != null) { |
| printHyperlink(pair.first, pair.second == null ? contentType : pair.second, null); |
| } |
| } |
| } |
| } |
| |
| private void printHyperlink(@NotNull String s, @NotNull ConsoleViewContentType contentType, @Nullable HyperlinkInfo info) { |
| synchronized (LOCK) { |
| Pair<String, Integer> pair = myBuffer.print(s, contentType, info); |
| s = pair.first; |
| myContentSize += s.length() - pair.second; |
| |
| if (contentType == ConsoleViewContentType.USER_INPUT && NEW_LINE_MATCHER.indexIn(s) >= 0) { |
| flushDeferredUserInput(); |
| } |
| if (myEditor != null && !myFlushAlarm.isDisposed()) { |
| final boolean shouldFlushNow = myBuffer.isUseCyclicBuffer() && myBuffer.getLength() >= myBuffer.getCyclicBufferSize(); |
| addFlushRequest(new MyFlushRunnable(), shouldFlushNow ? 0 : myFlushDelay); |
| } |
| } |
| } |
| |
| private void addToken(int length, @Nullable HyperlinkInfo info, ConsoleViewContentType contentType) { |
| ConsoleUtil.addToken(length, info, contentType, myTokens); |
| } |
| |
| private static ModalityState getStateForUpdate() { |
| return null;//myStateForUpdate != null ? myStateForUpdate.compute() : ModalityState.stateForComponent(this); |
| } |
| |
| private void requestFlushImmediately() { |
| if (myEditor != null && !myFlushAlarm.isDisposed()) { |
| addFlushRequest(new MyFlushRunnable()); |
| } |
| } |
| |
| @Override |
| public int getContentSize() { |
| synchronized (LOCK) { |
| return myContentSize; |
| } |
| } |
| |
| @Override |
| public boolean canPause() { |
| return true; |
| } |
| |
| public void flushDeferredText() { |
| flushDeferredText(false); |
| } |
| |
| private void flushDeferredText(boolean clear) { |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| if (myProject.isDisposed()) { |
| return; |
| } |
| EditorEx editor = myEditor; |
| if (editor == null) { |
| //already disposed |
| return; |
| } |
| if (clear) { |
| final DocumentEx document = editor.getDocument(); |
| synchronized (LOCK) { |
| myTokens.clear(); |
| clearHyperlinkAndFoldings(); |
| } |
| final int documentTextLength = document.getTextLength(); |
| if (documentTextLength > 0) { |
| CommandProcessor.getInstance().executeCommand(myProject, new Runnable() { |
| @Override |
| public void run() { |
| document.setInBulkUpdate(true); |
| try { |
| myInDocumentUpdate = true; |
| myDocumentClearing = true; |
| document.deleteString(0, documentTextLength); |
| } |
| finally { |
| document.setInBulkUpdate(false); |
| myDocumentClearing = false; |
| myInDocumentUpdate = false; |
| } |
| } |
| }, null, DocCommandGroupId.noneGroupId(document)); |
| } |
| } |
| |
| |
| final String addedText; |
| final Collection<ConsoleViewContentType> contentTypes; |
| int deferredTokensSize; |
| synchronized (LOCK) { |
| if (myOutputPaused) return; |
| if (myBuffer.isEmpty()) return; |
| |
| addedText = myBuffer.getText(); |
| |
| contentTypes = Collections.unmodifiableCollection(new HashSet<ConsoleViewContentType>(myBuffer.getDeferredTokenTypes())); |
| List<TokenInfo> deferredTokens = myBuffer.getDeferredTokens(); |
| for (TokenInfo deferredToken : deferredTokens) { |
| addToken(deferredToken.getLength(), deferredToken.getHyperlinkInfo(), deferredToken.contentType); |
| } |
| deferredTokensSize = deferredTokens.size(); |
| myBuffer.clear(false); |
| cancelHeavyAlarm(); |
| } |
| final Document document = myEditor.getDocument(); |
| final RangeMarker lastProcessedOutput = document.createRangeMarker(document.getTextLength(), document.getTextLength()); |
| final int caretOffset = myEditor.getCaretModel().getOffset(); |
| final boolean isAtLastLine = isCaretAtLastLine(); |
| |
| CommandProcessor.getInstance().executeCommand(myProject, new Runnable() { |
| @Override |
| public void run() { |
| boolean preserveCurrentVisualArea = caretOffset < document.getTextLength(); |
| if (preserveCurrentVisualArea) { |
| myEditor.getScrollingModel().accumulateViewportChanges(); |
| } |
| try { |
| myInDocumentUpdate = true; |
| String[] strings = addedText.split("\\r"); |
| for (int i = 0; i < strings.length - 1; i++) { |
| document.insertString(document.getTextLength(), strings[i]); |
| int lastLine = document.getLineCount() - 1; |
| if (lastLine >= 0) { |
| ConsoleUtil.updateTokensOnTextRemoval(myTokens, document.getTextLength(), document.getTextLength() + 1); |
| document.deleteString(document.getLineStartOffset(lastLine), document.getTextLength()); |
| } |
| } |
| if (strings.length > 0) { |
| document.insertString(document.getTextLength(), strings[strings.length - 1]); |
| myContentSize -= strings.length - 1; |
| } |
| } |
| finally { |
| myInDocumentUpdate = false; |
| if (preserveCurrentVisualArea) { |
| myEditor.getScrollingModel().flushViewportChanges(); |
| } |
| } |
| if (!contentTypes.isEmpty()) { |
| for (ChangeListener each : myListeners) { |
| each.contentAdded(contentTypes); |
| } |
| } |
| } |
| }, null, DocCommandGroupId.noneGroupId(document)); |
| synchronized (LOCK) { |
| for (int i = myTokens.size() - 1; i >= 0 && deferredTokensSize > 0; i--, deferredTokensSize--) { |
| TokenInfo token = myTokens.get(i); |
| final HyperlinkInfo info = token.getHyperlinkInfo(); |
| if (info != null) { |
| myHyperlinks.createHyperlink(token.startOffset, token.endOffset, null, info); |
| } |
| } |
| } |
| myPsiDisposedCheck.performCheck(); |
| myLastAddedTextLength = addedText.length(); |
| if (!myTooMuchOfOutput) { |
| if (isTheAmountOfTextTooBig(myLastAddedTextLength)) { // disable hyperlinks and folding until new output arriving slows down again |
| myTooMuchOfOutput = true; |
| final EditorNotificationPanel comp = |
| new EditorNotificationPanel().text("Too much output to process").icon(AllIcons.General.ExclMark); |
| final Alarm tooMuchOutputAlarm = new Alarm(); |
| //show the notification with a delay to avoid blinking when "too much output" ceases quickly |
| tooMuchOutputAlarm.addRequest(new Runnable() { |
| @Override |
| public void run() { |
| add(comp, BorderLayout.NORTH); |
| } |
| }, 300); |
| performWhenNoDeferredOutput(new Runnable() { |
| @Override |
| public void run() { |
| if (!isTheAmountOfTextTooBig(myLastAddedTextLength)) { |
| try { |
| highlightHyperlinksAndFoldings(lastProcessedOutput); |
| } |
| finally { |
| myTooMuchOfOutput = false; |
| remove(comp); |
| tooMuchOutputAlarm.cancelAllRequests(); |
| } |
| } |
| else { |
| myLastAddedTextLength = 0; |
| performLaterWhenNoDeferredOutput(this); |
| } |
| } |
| }); |
| } |
| else { |
| highlightHyperlinksAndFoldings(lastProcessedOutput); |
| } |
| } |
| |
| if (isAtLastLine) { |
| EditorUtil.scrollToTheEnd(myEditor); |
| } |
| } |
| |
| private boolean isTheAmountOfTextTooBig(final int textLength) { |
| return textLength > myBuffer.getCyclicBufferSize() / consoleTooMuchTextBufferRatio; |
| } |
| |
| private void clearHyperlinkAndFoldings() { |
| myEditor.getMarkupModel().removeAllHighlighters(); |
| |
| myPendingFoldRegions.clear(); |
| myFolding.clear(); |
| myFoldingAlarm.cancelAllRequests(); |
| myEditor.getFoldingModel().runBatchFoldingOperation(new Runnable() { |
| @Override |
| public void run() { |
| myEditor.getFoldingModel().clearFoldRegions(); |
| } |
| }); |
| |
| cancelHeavyAlarm(); |
| } |
| |
| private void cancelHeavyAlarm() { |
| if (myHeavyAlarm != null && !myHeavyAlarm.isDisposed()) { |
| myHeavyAlarm.cancelAllRequests(); |
| ++myHeavyUpdateTicket; |
| } |
| } |
| |
| private void flushDeferredUserInput() { |
| final String textToSend = myBuffer.cutFirstUserInputLine(); |
| if (textToSend == null) { |
| return; |
| } |
| myFlushUserInputAlarm.addRequest(new Runnable() { |
| @Override |
| public void run() { |
| if (myState.isRunning()) { |
| try { |
| // this may block forever, see IDEA-54340 |
| myState.sendUserInput(textToSend); |
| } |
| catch (IOException ignored) { |
| } |
| } |
| } |
| }, 0); |
| } |
| |
| @Override |
| public Object getData(final String dataId) { |
| if (CommonDataKeys.NAVIGATABLE.is(dataId)) { |
| if (myEditor == null) { |
| return null; |
| } |
| final LogicalPosition pos = myEditor.getCaretModel().getLogicalPosition(); |
| final HyperlinkInfo info = myHyperlinks.getHyperlinkInfoByLineAndCol(pos.line, pos.column); |
| final OpenFileDescriptor openFileDescriptor = info instanceof FileHyperlinkInfo ? ((FileHyperlinkInfo)info).getDescriptor() : null; |
| if (openFileDescriptor == null || !openFileDescriptor.getFile().isValid()) { |
| return null; |
| } |
| return openFileDescriptor; |
| } |
| |
| if (CommonDataKeys.EDITOR.is(dataId)) { |
| return myEditor; |
| } |
| if (PlatformDataKeys.HELP_ID.is(dataId)) { |
| return myHelpId; |
| } |
| if (LangDataKeys.CONSOLE_VIEW.is(dataId)) { |
| return this; |
| } |
| return null; |
| } |
| |
| @Override |
| public void setHelpId(final String helpId) { |
| myHelpId = helpId; |
| } |
| |
| public void setUpdateFoldingsEnabled(boolean updateFoldingsEnabled) { |
| myUpdateFoldingsEnabled = updateFoldingsEnabled; |
| } |
| |
| @Override |
| public void addMessageFilter(final Filter filter) { |
| myFilters.addFilter(filter); |
| } |
| |
| @Override |
| public void printHyperlink(final String hyperlinkText, final HyperlinkInfo info) { |
| printHyperlink(hyperlinkText, ConsoleViewContentType.NORMAL_OUTPUT, info); |
| } |
| |
| private EditorEx createEditor() { |
| return ApplicationManager.getApplication().runReadAction(new Computable<EditorEx>() { |
| @Override |
| public EditorEx compute() { |
| EditorEx editor = createRealEditor(); |
| editor.addEditorMouseListener(new EditorPopupHandler() { |
| @Override |
| public void invokePopup(final EditorMouseEvent event) { |
| popupInvoked(event.getMouseEvent()); |
| } |
| }); |
| editor.getDocument().addDocumentListener(new DocumentAdapter() { |
| @Override |
| public void documentChanged(DocumentEvent event) { |
| onDocumentChanged(event); |
| } |
| }, ConsoleViewImpl.this); |
| |
| int bufferSize = myBuffer.isUseCyclicBuffer() ? myBuffer.getCyclicBufferSize() : 0; |
| editor.getDocument().setCyclicBufferSize(bufferSize); |
| |
| editor.putUserData(CONSOLE_VIEW_IN_EDITOR_VIEW, ConsoleViewImpl.this); |
| |
| editor.getSettings().setAllowSingleLogicalLineFolding(true); // We want to fold long soft-wrapped command lines |
| editor.setHighlighter(createHighlighter()); |
| |
| return editor; |
| } |
| }); |
| } |
| |
| private void onDocumentChanged(DocumentEvent event) { |
| if (event.getNewLength() == 0) { |
| // string has been removed, adjust token ranges |
| synchronized (LOCK) { |
| ConsoleUtil.updateTokensOnTextRemoval(myTokens, event.getOffset(), event.getOffset() + event.getOldLength()); |
| int toRemoveLen = event.getOldLength(); |
| if (!myDocumentClearing) { |
| // If document is being cleared now, then this event has been occurred as a result of calling clear() method. |
| // At start clear() method sets 'myContentSize' to 0, so there is no need to perform update again. |
| // Moreover, performing update of 'myContentSize' breaks executing "console.print();" immediately after "console.clear();". |
| myContentSize -= Math.min(myContentSize, toRemoveLen); |
| } |
| } |
| } |
| else if (!myInDocumentUpdate) { |
| int newFragmentLength = event.getNewFragment().length(); |
| // track external appends |
| if (event.getOldFragment().length() == 0 && newFragmentLength > 0) { |
| synchronized (LOCK) { |
| myContentSize += newFragmentLength; |
| addToken(newFragmentLength, null, ConsoleViewContentType.NORMAL_OUTPUT); |
| } |
| } |
| else { |
| LOG.warn("unhandled external change: " + event); |
| } |
| } |
| } |
| |
| protected EditorEx createRealEditor() { |
| return ConsoleViewUtil.setupConsoleEditor(myProject, true, false); |
| } |
| |
| protected MyHighlighter createHighlighter() { |
| return new MyHighlighter(); |
| } |
| |
| private void registerConsoleEditorActions() { |
| HyperlinkNavigationAction hyperlinkNavigationAction = new HyperlinkNavigationAction(); |
| hyperlinkNavigationAction.registerCustomShortcutSet(CommonShortcuts.ENTER, myEditor.getContentComponent()); |
| registerActionHandler(myEditor, IdeActions.ACTION_GOTO_DECLARATION, hyperlinkNavigationAction); |
| |
| if (!myIsViewer) { |
| new EnterHandler().registerCustomShortcutSet(CommonShortcuts.ENTER, myEditor.getContentComponent()); |
| registerActionHandler(myEditor, IdeActions.ACTION_EDITOR_PASTE, new PasteHandler()); |
| registerActionHandler(myEditor, IdeActions.ACTION_EDITOR_BACKSPACE, new BackSpaceHandler()); |
| registerActionHandler(myEditor, IdeActions.ACTION_EDITOR_DELETE, new DeleteHandler()); |
| |
| registerActionHandler(myEditor, EOFAction.ACTION_ID, ActionManager.getInstance().getAction(EOFAction.ACTION_ID)); |
| } |
| } |
| |
| private static void registerActionHandler(final Editor editor, final String actionId, final AnAction action) { |
| final Keymap keymap = KeymapManager.getInstance().getActiveKeymap(); |
| final Shortcut[] shortcuts = keymap.getShortcuts(actionId); |
| action.registerCustomShortcutSet(new CustomShortcutSet(shortcuts), editor.getContentComponent()); |
| } |
| |
| private void popupInvoked(MouseEvent mouseEvent) { |
| final ActionManager actionManager = ActionManager.getInstance(); |
| final HyperlinkInfo info = myHyperlinks != null ? myHyperlinks.getHyperlinkInfoByPoint(mouseEvent.getPoint()) : null; |
| ActionGroup group = null; |
| if (info instanceof HyperlinkWithPopupMenuInfo) { |
| group = ((HyperlinkWithPopupMenuInfo)info).getPopupMenuGroup(mouseEvent); |
| } |
| if (group == null) { |
| group = (ActionGroup)actionManager.getAction(CONSOLE_VIEW_POPUP_MENU); |
| } |
| final ConsoleActionsPostProcessor[] postProcessors = Extensions.getExtensions(ConsoleActionsPostProcessor.EP_NAME); |
| AnAction[] result = group.getChildren(null); |
| |
| for (ConsoleActionsPostProcessor postProcessor : postProcessors) { |
| result = postProcessor.postProcessPopupActions(this, result); |
| } |
| final DefaultActionGroup processedGroup = new DefaultActionGroup(result); |
| final ActionPopupMenu menu = actionManager.createActionPopupMenu(ActionPlaces.EDITOR_POPUP, processedGroup); |
| menu.getComponent().show(mouseEvent.getComponent(), mouseEvent.getX(), mouseEvent.getY()); |
| } |
| |
| private void highlightHyperlinksAndFoldings(RangeMarker lastProcessedOutput) { |
| boolean canHighlightHyperlinks = !myFilters.isEmpty() || !myFilters.isEmpty(); |
| |
| if (!canHighlightHyperlinks && myUpdateFoldingsEnabled) { |
| return; |
| } |
| final int line1 = lastProcessedOutput.isValid() ? myEditor.getDocument().getLineNumber(lastProcessedOutput.getEndOffset()) : 0; |
| lastProcessedOutput.dispose(); |
| int endLine = myEditor.getDocument().getLineCount() - 1; |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| PsiDocumentManager.getInstance(myProject).commitAllDocuments(); |
| if (canHighlightHyperlinks) { |
| myHyperlinks.highlightHyperlinks(myFilters, line1, endLine); |
| } |
| |
| if (myAllowHeavyFilters && myFilters.isAnyHeavy() && myFilters.shouldRunHeavy()) { |
| runHeavyFilters(line1, endLine); |
| } |
| if (myUpdateFoldingsEnabled) { |
| updateFoldings(line1, endLine, true); |
| } |
| } |
| |
| private void runHeavyFilters(int line1, int endLine) { |
| final int startLine = Math.max(0, line1); |
| |
| final Document document = myEditor.getDocument(); |
| final int startOffset = document.getLineStartOffset(startLine); |
| String text = document.getText(new TextRange(startOffset, document.getLineEndOffset(endLine))); |
| final Document documentCopy = new DocumentImpl(text,true); |
| documentCopy.setReadOnly(true); |
| |
| myJLayeredPane.startUpdating(); |
| final int currentValue = myHeavyUpdateTicket; |
| assert myHeavyAlarm != null; |
| myHeavyAlarm.addRequest(new Runnable() { |
| @Override |
| public void run() { |
| if (!myFilters.shouldRunHeavy()) return; |
| try { |
| myFilters.applyHeavyFilter(documentCopy, startOffset, startLine, new Consumer<FilterMixin.AdditionalHighlight>() { |
| @Override |
| public void consume(final FilterMixin.AdditionalHighlight additionalHighlight) { |
| if (myFlushAlarm.isDisposed()) return; |
| addFlushRequest(new MyFlushRunnable() { |
| @Override |
| public void doRun() { |
| if (myHeavyUpdateTicket != currentValue) return; |
| myHyperlinks.addHighlighter(additionalHighlight.getStart(), additionalHighlight.getEnd(), |
| additionalHighlight.getTextAttributes(null)); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return this == o && super.equals(o); |
| } |
| }); |
| } |
| }); |
| } |
| finally { |
| if (myHeavyAlarm.isEmpty()) { |
| SwingUtilities.invokeLater(myFinishProgress); |
| } |
| } |
| } |
| }, 0); |
| } |
| |
| private void updateFoldings(final int line1, final int endLine, boolean immediately) { |
| final Document document = myEditor.getDocument(); |
| final CharSequence chars = document.getCharsSequence(); |
| final int startLine = Math.max(0, line1); |
| final List<FoldRegion> toAdd = new ArrayList<FoldRegion>(); |
| for (int line = startLine; line <= endLine; line++) { |
| addFolding(document, chars, line, toAdd); |
| } |
| if (!toAdd.isEmpty()) { |
| doUpdateFolding(toAdd, immediately); |
| } |
| } |
| |
| private void doUpdateFolding(final List<FoldRegion> toAdd, final boolean immediately) { |
| assertIsDispatchThread(); |
| myPendingFoldRegions.addAll(toAdd); |
| |
| myFoldingAlarm.cancelAllRequests(); |
| final Runnable runnable = new Runnable() { |
| @Override |
| public void run() { |
| if (myEditor == null || myEditor.isDisposed()) { |
| return; |
| } |
| |
| assertIsDispatchThread(); |
| final FoldingModel model = myEditor.getFoldingModel(); |
| final Runnable operation = new Runnable() { |
| @Override |
| public void run() { |
| assertIsDispatchThread(); |
| for (FoldRegion region : myPendingFoldRegions) { |
| region.setExpanded(false); |
| model.addFoldRegion(region); |
| } |
| myPendingFoldRegions.clear(); |
| } |
| }; |
| if (immediately) { |
| model.runBatchFoldingOperation(operation); |
| if (isCaretAtLastLine()) { |
| EditorUtil.scrollToTheEnd(myEditor); |
| } |
| } |
| else { |
| model.runBatchFoldingOperationDoNotCollapseCaret(operation); |
| } |
| } |
| }; |
| if (immediately || myPendingFoldRegions.size() > 100) { |
| runnable.run(); |
| } |
| else { |
| myFoldingAlarm.addRequest(runnable, 50); |
| } |
| } |
| |
| private boolean isCaretAtLastLine() { |
| final Document document = myEditor.getDocument(); |
| final int caretOffset = myEditor.getCaretModel().getOffset(); |
| return document.getLineNumber(caretOffset) >= document.getLineCount() - 1; |
| } |
| |
| private void addFolding(Document document, CharSequence chars, int line, List<FoldRegion> toAdd) { |
| String commandLinePlaceholder = myCommandLineFolding.getPlaceholder(line); |
| if (commandLinePlaceholder != null) { |
| FoldRegion region = myEditor.getFoldingModel().createFoldRegion( |
| document.getLineStartOffset(line), document.getLineEndOffset(line), commandLinePlaceholder, null, false |
| ); |
| toAdd.add(region); |
| return; |
| } |
| ConsoleFolding current = foldingForLine(EditorHyperlinkSupport.getLineText(document, line, false)); |
| if (current != null) { |
| myFolding.put(line, current); |
| } |
| |
| final ConsoleFolding prevFolding = myFolding.get(line - 1); |
| if (current == null && prevFolding != null) { |
| final int lEnd = line - 1; |
| int lStart = lEnd; |
| while (prevFolding.equals(myFolding.get(lStart - 1))) lStart--; |
| |
| for (int i = lStart; i <= lEnd; i++) { |
| myFolding.remove(i); |
| } |
| |
| List<String> toFold = new ArrayList<String>(lEnd - lStart + 1); |
| for (int i = lStart; i <= lEnd; i++) { |
| toFold.add(EditorHyperlinkSupport.getLineText(document, i, false)); |
| } |
| |
| int oStart = document.getLineStartOffset(lStart); |
| if (oStart > 0) oStart--; |
| int oEnd = CharArrayUtil.shiftBackward(chars, document.getLineEndOffset(lEnd) - 1, " \t") + 1; |
| |
| String placeholder = prevFolding.getPlaceholderText(toFold); |
| FoldRegion region = placeholder == null ? null : myEditor.getFoldingModel().createFoldRegion(oStart, oEnd, placeholder, null, false); |
| if (region != null) { |
| toAdd.add(region); |
| } |
| } |
| } |
| |
| @Nullable |
| private static ConsoleFolding foldingForLine(String lineText) { |
| for (ConsoleFolding folding : ConsoleFolding.EP_NAME.getExtensions()) { |
| if (folding.shouldFoldLine(lineText)) { |
| return folding; |
| } |
| } |
| return null; |
| } |
| |
| |
| public static class ClearAllAction extends DumbAwareAction { |
| public ClearAllAction() { |
| super(ExecutionBundle.message("clear.all.from.console.action.name"), "Clear the contents of the console", AllIcons.Actions.GC); |
| } |
| |
| @Override |
| public void update(AnActionEvent e) { |
| boolean enabled = e.getData(LangDataKeys.CONSOLE_VIEW) != null; |
| Editor editor = e.getData(CommonDataKeys.EDITOR); |
| if (editor != null && editor.getDocument().getTextLength() == 0) { |
| enabled = false; |
| } |
| e.getPresentation().setEnabled(enabled); |
| } |
| |
| @Override |
| public void actionPerformed(final AnActionEvent e) { |
| final ConsoleView consoleView = e.getData(LangDataKeys.CONSOLE_VIEW); |
| if (consoleView != null) { |
| consoleView.clear(); |
| } |
| } |
| } |
| |
| private class MyHighlighter extends DocumentAdapter implements EditorHighlighter { |
| private HighlighterClient myEditor; |
| |
| @NotNull |
| @Override |
| public HighlighterIterator createIterator(final int startOffset) { |
| final int startIndex = ConsoleUtil.findTokenInfoIndexByOffset(myTokens, startOffset); |
| |
| return new HighlighterIterator() { |
| private int myIndex = startIndex; |
| |
| @Override |
| public TextAttributes getTextAttributes() { |
| return getTokenInfo() == null ? null : getTokenInfo().attributes; |
| } |
| |
| @Override |
| public int getStart() { |
| return getTokenInfo() == null ? 0 : getTokenInfo().startOffset; |
| } |
| |
| @Override |
| public int getEnd() { |
| return getTokenInfo() == null ? 0 : getTokenInfo().endOffset; |
| } |
| |
| @Override |
| public IElementType getTokenType() { |
| return null; |
| } |
| |
| @Override |
| public void advance() { |
| myIndex++; |
| } |
| |
| @Override |
| public void retreat() { |
| myIndex--; |
| } |
| |
| @Override |
| public boolean atEnd() { |
| return myIndex < 0 || myIndex >= myTokens.size(); |
| } |
| |
| @Override |
| public Document getDocument() { |
| return myEditor.getDocument(); |
| } |
| |
| private TokenInfo getTokenInfo() { |
| return myTokens.get(myIndex); |
| } |
| }; |
| } |
| |
| @Override |
| public void setText(@NotNull final CharSequence text) { |
| } |
| |
| @Override |
| public void setEditor(@NotNull final HighlighterClient editor) { |
| LOG.assertTrue(myEditor == null, "Highlighters cannot be reused with different editors"); |
| myEditor = editor; |
| } |
| |
| @Override |
| public void setColorScheme(@NotNull EditorColorsScheme scheme) { |
| } |
| } |
| |
| private static class MyTypedHandler extends TypedActionHandlerBase { |
| |
| private MyTypedHandler(final TypedActionHandler originalAction) { |
| super(originalAction); |
| } |
| |
| @Override |
| public void execute(@NotNull final Editor editor, final char charTyped, @NotNull final DataContext dataContext) { |
| final ConsoleViewImpl consoleView = editor.getUserData(CONSOLE_VIEW_IN_EDITOR_VIEW); |
| if (consoleView == null || !consoleView.myState.isRunning() || consoleView.myIsViewer) { |
| if (myOriginalHandler != null) myOriginalHandler.execute(editor, charTyped, dataContext); |
| } |
| else { |
| final String s = String.valueOf(charTyped); |
| SelectionModel selectionModel = editor.getSelectionModel(); |
| if (selectionModel.hasSelection()) { |
| consoleView.replaceUserText(s, selectionModel.getSelectionStart(), selectionModel.getSelectionEnd()); |
| } |
| else { |
| consoleView.insertUserText(s, editor.getCaretModel().getOffset()); |
| } |
| } |
| } |
| } |
| |
| private abstract static class ConsoleAction extends AnAction implements DumbAware { |
| @Override |
| public void actionPerformed(final AnActionEvent e) { |
| final DataContext context = e.getDataContext(); |
| final ConsoleViewImpl console = getRunningConsole(context); |
| execute(console, context); |
| } |
| |
| protected abstract void execute(ConsoleViewImpl console, final DataContext context); |
| |
| @Override |
| public void update(final AnActionEvent e) { |
| final ConsoleViewImpl console = getRunningConsole(e.getDataContext()); |
| e.getPresentation().setEnabled(console != null); |
| } |
| |
| @Nullable |
| private static ConsoleViewImpl getRunningConsole(final DataContext context) { |
| final Editor editor = CommonDataKeys.EDITOR.getData(context); |
| if (editor != null) { |
| final ConsoleViewImpl console = editor.getUserData(CONSOLE_VIEW_IN_EDITOR_VIEW); |
| if (console != null && console.myState.isRunning()) { |
| return console; |
| } |
| } |
| return null; |
| } |
| } |
| |
| private static class EnterHandler extends ConsoleAction { |
| @Override |
| public void execute(final ConsoleViewImpl consoleView, final DataContext context) { |
| consoleView.print("\n", ConsoleViewContentType.USER_INPUT); |
| consoleView.flushDeferredText(); |
| final Editor editor = consoleView.myEditor; |
| editor.getCaretModel().moveToOffset(editor.getDocument().getTextLength()); |
| editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); |
| } |
| } |
| |
| private static class PasteHandler extends ConsoleAction { |
| @Override |
| public void execute(final ConsoleViewImpl consoleView, final DataContext context) { |
| String s = CopyPasteManager.getInstance().getContents(DataFlavor.stringFlavor); |
| if (s == null) return; |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| Editor editor = consoleView.myEditor; |
| SelectionModel selectionModel = editor.getSelectionModel(); |
| if (selectionModel.hasSelection()) { |
| consoleView.replaceUserText(s, selectionModel.getSelectionStart(), selectionModel.getSelectionEnd()); |
| } |
| else { |
| consoleView.insertUserText(s, editor.getCaretModel().getOffset()); |
| } |
| } |
| } |
| |
| private static class BackSpaceHandler extends ConsoleAction { |
| @Override |
| public void execute(final ConsoleViewImpl consoleView, final DataContext context) { |
| final Editor editor = consoleView.myEditor; |
| |
| if (IncrementalSearchHandler.isHintVisible(editor)) { |
| getDefaultActionHandler().execute(editor, context); |
| return; |
| } |
| |
| final Document document = editor.getDocument(); |
| final int length = document.getTextLength(); |
| if (length == 0) { |
| return; |
| } |
| |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| |
| SelectionModel selectionModel = editor.getSelectionModel(); |
| if (selectionModel.hasSelection()) { |
| consoleView.deleteUserText(selectionModel.getSelectionStart(), |
| selectionModel.getSelectionEnd() - selectionModel.getSelectionStart()); |
| } |
| else if (editor.getCaretModel().getOffset() > 0) { |
| consoleView.deleteUserText(editor.getCaretModel().getOffset() - 1, 1); |
| } |
| } |
| |
| private static EditorActionHandler getDefaultActionHandler() { |
| return EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_BACKSPACE); |
| } |
| } |
| |
| private static class DeleteHandler extends ConsoleAction { |
| @Override |
| public void execute(final ConsoleViewImpl consoleView, final DataContext context) { |
| final Editor editor = consoleView.myEditor; |
| |
| if (IncrementalSearchHandler.isHintVisible(editor)) { |
| getDefaultActionHandler().execute(editor, context); |
| return; |
| } |
| |
| final Document document = editor.getDocument(); |
| final int length = document.getTextLength(); |
| if (length == 0) { |
| return; |
| } |
| |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| SelectionModel selectionModel = editor.getSelectionModel(); |
| if (selectionModel.hasSelection()) { |
| consoleView.deleteUserText(selectionModel.getSelectionStart(), |
| selectionModel.getSelectionEnd() - selectionModel.getSelectionStart()); |
| } |
| else { |
| consoleView.deleteUserText(editor.getCaretModel().getOffset(), 1); |
| } |
| } |
| |
| private static EditorActionHandler getDefaultActionHandler() { |
| return EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_BACKSPACE); |
| } |
| } |
| |
| @Override |
| public JComponent getPreferredFocusableComponent() { |
| //ensure editor created |
| getComponent(); |
| return myEditor.getContentComponent(); |
| } |
| |
| |
| // navigate up/down in stack trace |
| @Override |
| public boolean hasNextOccurence() { |
| return calcNextOccurrence(1) != null; |
| } |
| |
| @Override |
| public boolean hasPreviousOccurence() { |
| return calcNextOccurrence(-1) != null; |
| } |
| |
| @Override |
| public OccurenceInfo goNextOccurence() { |
| return calcNextOccurrence(1); |
| } |
| |
| @Nullable |
| protected OccurenceInfo calcNextOccurrence(final int delta) { |
| final EditorHyperlinkSupport hyperlinks = myHyperlinks; |
| if (hyperlinks == null) { |
| return null; |
| } |
| |
| return EditorHyperlinkSupport.getNextOccurrence(myEditor, delta, new Consumer<RangeHighlighter>() { |
| @Override |
| public void consume(RangeHighlighter next) { |
| int offset = next.getStartOffset(); |
| scrollTo(offset); |
| final HyperlinkInfo hyperlinkInfo = EditorHyperlinkSupport.getHyperlinkInfo(next); |
| if (hyperlinkInfo instanceof HyperlinkInfoBase) { |
| VisualPosition position = myEditor.offsetToVisualPosition(offset); |
| Point point = myEditor.visualPositionToXY(new VisualPosition(position.getLine() + 1, position.getColumn())); |
| ((HyperlinkInfoBase)hyperlinkInfo).navigate(myProject, new RelativePoint(myEditor.getContentComponent(), point)); |
| } |
| else if (hyperlinkInfo != null) { |
| hyperlinkInfo.navigate(myProject); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public OccurenceInfo goPreviousOccurence() { |
| return calcNextOccurrence(-1); |
| } |
| |
| @Override |
| public String getNextOccurenceActionName() { |
| return ExecutionBundle.message("down.the.stack.trace"); |
| } |
| |
| @Override |
| public String getPreviousOccurenceActionName() { |
| return ExecutionBundle.message("up.the.stack.trace"); |
| } |
| |
| public void addCustomConsoleAction(@NotNull AnAction action) { |
| customActions.add(action); |
| } |
| |
| @Override |
| @NotNull |
| public AnAction[] createConsoleActions() { |
| //Initializing prev and next occurrences actions |
| final CommonActionsManager actionsManager = CommonActionsManager.getInstance(); |
| final AnAction prevAction = actionsManager.createPrevOccurenceAction(this); |
| prevAction.getTemplatePresentation().setText(getPreviousOccurenceActionName()); |
| final AnAction nextAction = actionsManager.createNextOccurenceAction(this); |
| nextAction.getTemplatePresentation().setText(getNextOccurenceActionName()); |
| |
| final AnAction switchSoftWrapsAction = new ToggleUseSoftWrapsToolbarAction(SoftWrapAppliancePlaces.CONSOLE) { |
| |
| /** |
| * There is a possible case that more than console is open and user toggles soft wraps mode at one of them. We want |
| * to update another console(s) representation as well when they are switched on after that. Hence, we remember last |
| * used soft wraps mode and perform update if we see that the current value differs from the stored. |
| */ |
| private boolean myLastIsSelected; |
| |
| @Override |
| protected Editor getEditor(AnActionEvent e) { |
| return myEditor; |
| } |
| |
| @Override |
| public boolean isSelected(AnActionEvent e) { |
| boolean result = super.isSelected(e); |
| if (result ^ myLastIsSelected) { |
| setSelected(null, result); |
| } |
| return myLastIsSelected = result; |
| } |
| |
| @Override |
| public void setSelected(AnActionEvent e, final boolean state) { |
| super.setSelected(e, state); |
| if (myEditor == null) { |
| return; |
| } |
| |
| final String placeholder = myCommandLineFolding.getPlaceholder(0); |
| final FoldingModel foldingModel = myEditor.getFoldingModel(); |
| final int firstLineEnd = myEditor.getDocument().getLineEndOffset(0); |
| foldingModel.runBatchFoldingOperation(new Runnable() { |
| @Override |
| public void run() { |
| FoldRegion[] regions = foldingModel.getAllFoldRegions(); |
| if (regions.length > 0 && regions[0].getStartOffset() == 0 && regions[0].getEndOffset() == firstLineEnd) { |
| foldingModel.removeFoldRegion(regions[0]); |
| } |
| if (placeholder != null) { |
| FoldRegion foldRegion = foldingModel.addFoldRegion(0, firstLineEnd, placeholder); |
| if (foldRegion != null) { |
| foldRegion.setExpanded(false); |
| } |
| } |
| } |
| }); |
| } |
| }; |
| final AnAction autoScrollToTheEndAction = new ScrollToTheEndToolbarAction(myEditor); |
| |
| //Initializing custom actions |
| final AnAction[] consoleActions = new AnAction[6 + customActions.size()]; |
| consoleActions[0] = prevAction; |
| consoleActions[1] = nextAction; |
| consoleActions[2] = switchSoftWrapsAction; |
| consoleActions[3] = autoScrollToTheEndAction; |
| consoleActions[4] = ActionManager.getInstance().getAction("Print"); |
| consoleActions[5] = new ClearAllAction(); |
| for (int i = 0; i < customActions.size(); ++i) { |
| consoleActions[i + 6] = customActions.get(i); |
| } |
| ConsoleActionsPostProcessor[] postProcessors = Extensions.getExtensions(ConsoleActionsPostProcessor.EP_NAME); |
| AnAction[] result = consoleActions; |
| for (ConsoleActionsPostProcessor postProcessor : postProcessors) { |
| result = postProcessor.postProcess(this, result); |
| } |
| return result; |
| } |
| |
| @Override |
| public void allowHeavyFilters() { |
| myAllowHeavyFilters = true; |
| } |
| |
| @Override |
| public void addChangeListener(@NotNull final ChangeListener listener, @NotNull final Disposable parent) { |
| myListeners.add(listener); |
| Disposer.register(parent, new Disposable() { |
| @Override |
| public void dispose() { |
| myListeners.remove(listener); |
| } |
| }); |
| } |
| |
| /** |
| * insert text to document |
| * |
| * @param s inserted text |
| * @param offset relatively to all document text |
| */ |
| private void insertUserText(final String s, int offset) { |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| final ConsoleViewImpl consoleView = this; |
| final ConsoleBuffer buffer = consoleView.myBuffer; |
| final Editor editor = consoleView.myEditor; |
| final Document document = editor.getDocument(); |
| final int startOffset; |
| |
| String textToUse = StringUtil.convertLineSeparators(s); |
| synchronized (consoleView.LOCK) { |
| if (consoleView.myTokens.isEmpty()) return; |
| final TokenInfo info = consoleView.myTokens.get(consoleView.myTokens.size() - 1); |
| if (info.contentType != ConsoleViewContentType.USER_INPUT && !StringUtil.containsChar(textToUse, '\n')) { |
| consoleView.print(textToUse, ConsoleViewContentType.USER_INPUT); |
| consoleView.flushDeferredText(); |
| editor.getCaretModel().moveToOffset(document.getTextLength()); |
| editor.getSelectionModel().removeSelection(); |
| return; |
| } |
| if (info.contentType != ConsoleViewContentType.USER_INPUT) { |
| insertUserText("temp", offset); |
| final TokenInfo newInfo = consoleView.myTokens.get(consoleView.myTokens.size() - 1); |
| replaceUserText(textToUse, newInfo.startOffset, newInfo.endOffset); |
| return; |
| } |
| |
| final int deferredOffset = myContentSize - buffer.getLength() - buffer.getUserInputLength(); |
| if (offset > info.endOffset) { |
| startOffset = info.endOffset; |
| } |
| else { |
| startOffset = Math.max(deferredOffset, Math.max(info.startOffset, offset)); |
| } |
| |
| buffer.addUserText(startOffset - deferredOffset, textToUse); |
| |
| int charCountToAdd = textToUse.length(); |
| info.endOffset += charCountToAdd; |
| consoleView.myContentSize += charCountToAdd; |
| } |
| |
| try { |
| myInDocumentUpdate = true; |
| document.insertString(startOffset, textToUse); |
| } |
| finally { |
| myInDocumentUpdate = false; |
| } |
| // Math.max is needed when cyclic buffer is used |
| editor.getCaretModel().moveToOffset(Math.min(startOffset + textToUse.length(), document.getTextLength())); |
| editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); |
| } |
| |
| /** |
| * replace text |
| * |
| * @param s text for replace |
| * @param start relatively to all document text |
| * @param end relatively to all document text |
| */ |
| private void replaceUserText(final String s, int start, int end) { |
| if (start == end) { |
| insertUserText(s, start); |
| return; |
| } |
| final ConsoleViewImpl consoleView = this; |
| final ConsoleBuffer buffer = consoleView.myBuffer; |
| final Editor editor = consoleView.myEditor; |
| final Document document = editor.getDocument(); |
| final int startOffset; |
| final int endOffset; |
| |
| synchronized (consoleView.LOCK) { |
| if (consoleView.myTokens.isEmpty()) return; |
| final TokenInfo info = consoleView.myTokens.get(consoleView.myTokens.size() - 1); |
| if (info.contentType != ConsoleViewContentType.USER_INPUT) { |
| consoleView.print(s, ConsoleViewContentType.USER_INPUT); |
| consoleView.flushDeferredText(); |
| editor.getCaretModel().moveToOffset(document.getTextLength()); |
| editor.getSelectionModel().removeSelection(); |
| return; |
| } |
| if (buffer.getUserInputLength() <= 0) return; |
| |
| final int deferredOffset = myContentSize - buffer.getLength() - buffer.getUserInputLength(); |
| |
| startOffset = getStartOffset(start, info, deferredOffset); |
| endOffset = getEndOffset(end, info); |
| |
| if (startOffset == -1 || |
| endOffset == -1 || |
| endOffset <= startOffset) { |
| editor.getSelectionModel().removeSelection(); |
| editor.getCaretModel().moveToOffset(start); |
| return; |
| } |
| int charCountToReplace = s.length() - endOffset + startOffset; |
| |
| buffer.replaceUserText(startOffset - deferredOffset, endOffset - deferredOffset, s); |
| |
| info.endOffset += charCountToReplace; |
| if (info.startOffset == info.endOffset) { |
| consoleView.myTokens.remove(consoleView.myTokens.size() - 1); |
| } |
| consoleView.myContentSize += charCountToReplace; |
| } |
| |
| try { |
| myInDocumentUpdate = true; |
| document.replaceString(startOffset, endOffset, s); |
| } |
| finally { |
| myInDocumentUpdate = false; |
| } |
| editor.getCaretModel().moveToOffset(startOffset + s.length()); |
| editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); |
| editor.getSelectionModel().removeSelection(); |
| } |
| |
| /** |
| * delete text |
| * |
| * @param offset relatively to all document text |
| * @param length length of deleted text |
| */ |
| private void deleteUserText(int offset, int length) { |
| ConsoleViewImpl consoleView = this; |
| ConsoleBuffer buffer = consoleView.myBuffer; |
| final Editor editor = consoleView.myEditor; |
| final Document document = editor.getDocument(); |
| final int startOffset; |
| final int endOffset; |
| |
| synchronized (consoleView.LOCK) { |
| if (consoleView.myTokens.isEmpty()) return; |
| final TokenInfo info = consoleView.myTokens.get(consoleView.myTokens.size() - 1); |
| if (info.contentType != ConsoleViewContentType.USER_INPUT) return; |
| if (myBuffer.getUserInputLength() == 0) return; |
| |
| final int deferredOffset = myContentSize - buffer.getLength() - buffer.getUserInputLength(); |
| startOffset = getStartOffset(offset, info, deferredOffset); |
| endOffset = getEndOffset(offset + length, info); |
| if (startOffset == -1 || |
| endOffset == -1 || |
| endOffset <= startOffset || |
| startOffset < deferredOffset) { |
| editor.getSelectionModel().removeSelection(); |
| editor.getCaretModel().moveToOffset(offset); |
| return; |
| } |
| |
| buffer.removeUserText(startOffset - deferredOffset, endOffset - deferredOffset); |
| } |
| |
| try { |
| myInDocumentUpdate = true; |
| document.deleteString(startOffset, endOffset); |
| } |
| finally { |
| myInDocumentUpdate = false; |
| } |
| editor.getCaretModel().moveToOffset(startOffset); |
| editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); |
| editor.getSelectionModel().removeSelection(); |
| } |
| |
| //util methods for add, replace, delete methods |
| private static int getStartOffset(int offset, TokenInfo info, int deferredOffset) { |
| int startOffset; |
| if (offset >= info.startOffset && offset < info.endOffset) { |
| startOffset = Math.max(offset, deferredOffset); |
| } |
| else if (offset < info.startOffset) { |
| startOffset = Math.max(info.startOffset, deferredOffset); |
| } |
| else { |
| startOffset = -1; |
| } |
| return startOffset; |
| } |
| |
| private static int getEndOffset(int offset, TokenInfo info) { |
| int endOffset; |
| if (offset > info.endOffset) { |
| endOffset = info.endOffset; |
| } |
| else if (offset <= info.startOffset) { |
| endOffset = -1; |
| } |
| else { |
| endOffset = offset; |
| } |
| return endOffset; |
| } |
| |
| public boolean isRunning() { |
| return myState.isRunning(); |
| } |
| |
| /** |
| * Command line used to launch application/test from idea may be quite long. |
| * Hence, it takes many visual lines during representation if soft wraps are enabled |
| * or, otherwise, takes many columns and makes horizontal scrollbar thumb too small. |
| * <p/> |
| * Our point is to fold such long command line and represent it as a single visual line by default. |
| */ |
| private class CommandLineFolding extends ConsoleFolding { |
| |
| /** |
| * Checks if target line should be folded and returns its placeholder if the examination succeeds. |
| * |
| * @param line index of line to check |
| * @return placeholder text if given line should be folded; <code>null</code> otherwise |
| */ |
| @Nullable |
| public String getPlaceholder(int line) { |
| if (myEditor == null || line != 0) { |
| return null; |
| } |
| |
| String text = EditorHyperlinkSupport.getLineText(myEditor.getDocument(), 0, false); |
| // Don't fold the first line if the line is not that big. |
| if (text.length() < 1000) { |
| return null; |
| } |
| boolean nonWhiteSpaceFound = false; |
| int index = 0; |
| for (; index < text.length(); index++) { |
| char c = text.charAt(index); |
| if (c != ' ' && c != '\t') { |
| nonWhiteSpaceFound = true; |
| continue; |
| } |
| if (nonWhiteSpaceFound) { |
| break; |
| } |
| } |
| assert index <= text.length(); |
| return text.substring(0, index) + " ..."; |
| } |
| |
| @Override |
| public boolean shouldFoldLine(String line) { |
| return false; |
| } |
| |
| @Override |
| public String getPlaceholderText(List<String> lines) { |
| // Is not expected to be called. |
| return "<...>"; |
| } |
| } |
| |
| private class MyFlushRunnable implements Runnable { |
| private volatile boolean myValid = true; |
| @Override |
| public final void run() { |
| synchronized (myCurrentRequests) { |
| myCurrentRequests.remove(this); |
| } |
| if (myValid) { |
| doRun(); |
| } |
| } |
| |
| protected void doRun() { |
| flushDeferredText(); |
| } |
| |
| public void invalidate() { |
| myValid = false; |
| } |
| |
| public boolean isValid() { |
| return myValid; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (o == null || getClass() != o.getClass()) return false; |
| |
| MyFlushRunnable runnable = (MyFlushRunnable)o; |
| |
| return myValid == runnable.myValid; |
| } |
| |
| @Override |
| public int hashCode() { |
| return getClass().hashCode(); |
| } |
| } |
| |
| private final class MyClearRunnable extends MyFlushRunnable { |
| @Override |
| public void doRun() { |
| flushDeferredText(true); |
| } |
| } |
| |
| @NotNull |
| public Project getProject() { |
| return myProject; |
| } |
| |
| private class HyperlinkNavigationAction extends DumbAwareAction { |
| @Override |
| public void actionPerformed(AnActionEvent e) { |
| Runnable runnable = myHyperlinks.getLinkNavigationRunnable(myEditor.getCaretModel().getLogicalPosition()); |
| assert runnable != null; |
| runnable.run(); |
| } |
| |
| @Override |
| public void update(AnActionEvent e) { |
| e.getPresentation().setEnabled(myHyperlinks.getLinkNavigationRunnable(myEditor.getCaretModel().getLogicalPosition()) != null); |
| } |
| } |
| } |
| |
