added restriction to debug command line to execute only on paused process
authorDmitry Trofimov <dmitry.trofimov@jetbrains.com>
Sat, 6 Nov 2010 18:23:33 +0000 (21:23 +0300)
committerDmitry Trofimov <dmitry.trofimov@jetbrains.com>
Sat, 6 Nov 2010 18:23:33 +0000 (21:23 +0300)
platform/lang-impl/src/com/intellij/execution/console/LanguageConsoleImpl.java
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/tree/SetValueInplaceEditor.java

index 6f25972c3e5a8e35ca62383686d127c73c96eda4..012eb2e143b8e60cb769a258f34adfb1210ed6e9 100644 (file)
-/*
- * Copyright 2000-2010 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.console;
-
-import com.intellij.execution.ui.ConsoleViewContentType;
-import com.intellij.ide.DataManager;
-import com.intellij.ide.impl.TypeSafeDataProviderAdapter;
-import com.intellij.lang.Language;
-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.editor.*;
-import com.intellij.openapi.editor.actions.EditorActionUtil;
-import com.intellij.openapi.editor.colors.EditorColors;
-import com.intellij.openapi.editor.event.*;
-import com.intellij.openapi.editor.ex.EditorEx;
-import com.intellij.openapi.editor.ex.RangeHighlighterEx;
-import com.intellij.openapi.editor.ex.util.EditorUtil;
-import com.intellij.openapi.editor.highlighter.EditorHighlighterFactory;
-import com.intellij.openapi.editor.highlighter.HighlighterIterator;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.editor.impl.EditorFactoryImpl;
-import com.intellij.openapi.editor.impl.EditorImpl;
-import com.intellij.openapi.editor.markup.*;
-import com.intellij.openapi.fileEditor.FileEditor;
-import com.intellij.openapi.fileEditor.FileEditorManager;
-import com.intellij.openapi.fileEditor.OpenFileDescriptor;
-import com.intellij.openapi.fileEditor.TextEditor;
-import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
-import com.intellij.openapi.fileEditor.impl.EditorWindow;
-import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl;
-import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl;
-import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.StdFileTypes;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.Ref;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiFileFactory;
-import com.intellij.psi.impl.PsiDocumentManagerImpl;
-import com.intellij.psi.impl.PsiFileFactoryImpl;
-import com.intellij.psi.impl.PsiManagerEx;
-import com.intellij.testFramework.LightVirtualFile;
-import com.intellij.ui.SideBorder;
-import com.intellij.util.FileContentUtil;
-import com.intellij.util.ui.UIUtil;
-import com.intellij.util.ui.update.MergingUpdateQueue;
-import com.intellij.util.ui.update.Update;
-import org.jetbrains.annotations.NonNls;
-
-import javax.swing.FocusManager;
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.*;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * @author Gregory.Shrago
- */
-public class LanguageConsoleImpl implements Disposable, TypeSafeDataProvider {
-  private static final int SEPARATOR_THICKNESS = 1;
-
-  private final Project myProject;
-
-  private final EditorEx myConsoleEditor;
-  private final EditorEx myHistoryViewer;
-  private final Document myEditorDocument;
-  protected PsiFile myFile;
-
-  private final JPanel myPanel = new JPanel(new BorderLayout());
-
-  private String myTitle;
-  private String myPrompt = "> ";
-  private final LightVirtualFile myHistoryFile;
-
-  private Editor myCurrentEditor;
-
-  private final AtomicBoolean myForceScrollToEnd = new AtomicBoolean(false);
-  private final MergingUpdateQueue myUpdateQueue;
-  private Runnable myUiUpdateRunnable;
-
-  private Editor myFullEditor;
-  private ActionGroup myFullEditorActions;
-  private final boolean myDoSaveErrorsToHistory;
-
-  public LanguageConsoleImpl(final Project project, String title, final Language language, final boolean doSaveErrorsToHistory) {
-    myProject = project;
-    myTitle = title;
-    myDoSaveErrorsToHistory = doSaveErrorsToHistory;
-    installEditorFactoryListener();
-    final EditorFactory editorFactory = EditorFactory.getInstance();
-    myHistoryFile = new LightVirtualFile(getTitle() + ".history.txt", StdFileTypes.PLAIN_TEXT, "");
-    myEditorDocument = editorFactory.createDocument("");
-    setLanguage(language);
-    myConsoleEditor = (EditorEx)editorFactory.createEditor(myEditorDocument, myProject);
-    myConsoleEditor.setBackgroundColor(myConsoleEditor.getColorsScheme().getColor(ConsoleViewContentType.CONSOLE_BACKGROUND_KEY));
-    myCurrentEditor = myConsoleEditor;
-    myHistoryViewer = (EditorEx)editorFactory.createViewer(((EditorFactoryImpl)editorFactory).createDocument(true), myProject);
-    myHistoryViewer.setBackgroundColor(myHistoryViewer.getColorsScheme().getColor(ConsoleViewContentType.CONSOLE_BACKGROUND_KEY));
-    myPanel.add(myHistoryViewer.getComponent(), BorderLayout.NORTH);
-    myPanel.add(myConsoleEditor.getComponent(), BorderLayout.CENTER);
-    setupComponents();
-    myPanel.putClientProperty(DataManager.CLIENT_PROPERTY_DATA_PROVIDER, new TypeSafeDataProviderAdapter(this));
-    myUpdateQueue = new MergingUpdateQueue("ConsoleUpdateQueue", 300, true, null);
-    Disposer.register(this, myUpdateQueue);
-    myPanel.addComponentListener(new ComponentAdapter() {
-      public void componentResized(ComponentEvent e) {
-        try {
-          myHistoryViewer.getScrollingModel().disableAnimation();
-          updateSizes(true);
-        }
-        finally {
-          myHistoryViewer.getScrollingModel().enableAnimation();
-        }
-      }
-
-      public void componentShown(ComponentEvent e) {
-        componentResized(e);
-      }
-    });
-  }
-
-  public void setFullEditorMode(boolean fullEditorMode) {
-    if (myFullEditor != null == fullEditorMode) return;
-    final VirtualFile virtualFile = myFile.getVirtualFile();
-    assert virtualFile != null;
-    final FileEditorManagerEx fileManager = FileEditorManagerEx.getInstanceEx(getProject());
-    if (!fullEditorMode) {
-      fileManager.closeFile(virtualFile);
-      myFullEditor = null;
-      myPanel.removeAll();
-      myPanel.add(myHistoryViewer.getComponent(), BorderLayout.NORTH);
-      myPanel.add(myConsoleEditor.getComponent(), BorderLayout.CENTER);
-
-      myHistoryViewer.setHorizontalScrollbarVisible(false);
-    }
-    else {
-      myPanel.removeAll();
-      myPanel.add(myHistoryViewer.getComponent(), BorderLayout.CENTER);
-      myFullEditor = fileManager.openTextEditor(new OpenFileDescriptor(getProject(), virtualFile, 0), true);
-      assert myFullEditor != null;
-      configureFullEditor();
-      EditorWindow editorWindow = EditorWindow.DATA_KEY.getData(DataManager.getInstance().getDataContext(myFullEditor.getComponent()));
-      if (editorWindow == null) {
-        editorWindow = fileManager.getCurrentWindow();
-      }
-      if (editorWindow != null) {
-        editorWindow.setFilePinned(virtualFile, true);
-      }
-
-      myHistoryViewer.setHorizontalScrollbarVisible(true);
-    }
-  }
-
-  public void setFullEditorActions(ActionGroup actionGroup) {
-    myFullEditorActions = actionGroup;
-    configureFullEditor();
-  }
-
-  private void setupComponents() {
-    setupEditorDefault(myConsoleEditor);
-    setupEditorDefault(myHistoryViewer);
-    setPrompt(myPrompt);
-    myConsoleEditor.addEditorMouseListener(EditorActionUtil.createEditorPopupHandler(IdeActions.GROUP_CUT_COPY_PASTE));
-    if (SEPARATOR_THICKNESS > 0) {
-      myHistoryViewer.getComponent().setBorder(new SideBorder(Color.LIGHT_GRAY, SideBorder.BOTTOM));
-    }
-    myHistoryViewer.getComponent().setMinimumSize(new Dimension(0, 0));
-    myHistoryViewer.getComponent().setPreferredSize(new Dimension(0, 0));
-    myConsoleEditor.getSettings().setAdditionalLinesCount(2);
-    myConsoleEditor.setHighlighter(EditorHighlighterFactory.getInstance().createEditorHighlighter(myProject, myFile.getVirtualFile()));
-    myHistoryViewer.setCaretEnabled(false);
-    myConsoleEditor.setHorizontalScrollbarVisible(true);
-    final VisibleAreaListener areaListener = new VisibleAreaListener() {
-      public void visibleAreaChanged(VisibleAreaEvent e) {
-        final int offset = myConsoleEditor.getScrollingModel().getHorizontalScrollOffset();
-        final ScrollingModel model = myHistoryViewer.getScrollingModel();
-        final int historyOffset = model.getHorizontalScrollOffset();
-        if (historyOffset != offset) {
-          try {
-            model.disableAnimation();
-            model.scrollHorizontally(offset);
-          }
-          finally {
-            model.enableAnimation();
-          }
-        }
-      }
-    };
-    myConsoleEditor.getScrollingModel().addVisibleAreaListener(areaListener);
-    final DocumentAdapter docListener = new DocumentAdapter() {
-      @Override
-      public void documentChanged(final DocumentEvent e) {
-        queueUiUpdate(false);
-      }
-    };
-    myEditorDocument.addDocumentListener(docListener, this);
-    myHistoryViewer.getDocument().addDocumentListener(docListener, this);
-
-    myHistoryViewer.getContentComponent().addKeyListener(new KeyAdapter() {
-      public void keyTyped(KeyEvent event) {
-        if (myFullEditor == null && UIUtil.isReallyTypedEvent(event)) {
-          myConsoleEditor.getContentComponent().requestFocus();
-          myConsoleEditor.processKeyTyped(event);
-        }
-      }
-    });
-    for (AnAction action : createActions()) {
-      action.registerCustomShortcutSet(action.getShortcutSet(), myConsoleEditor.getComponent());
-    }
-    registerActionShortcuts(myHistoryViewer.getComponent());
-  }
-
-  protected AnAction[] createActions() {
-    return AnAction.EMPTY_ARRAY;
-  }
-
-  private static void setupEditorDefault(EditorEx editor) {
-    editor.getContentComponent().setFocusCycleRoot(false);
-    editor.setHorizontalScrollbarVisible(false);
-    editor.setVerticalScrollbarVisible(true);
-    editor.getColorsScheme().setColor(EditorColors.CARET_ROW_COLOR, null);
-    editor.setBorder(null);
-    editor.getContentComponent().setFocusCycleRoot(false);
-
-    final EditorSettings editorSettings = editor.getSettings();
-    editorSettings.setAdditionalLinesCount(0);
-    editorSettings.setAdditionalColumnsCount(1);
-    editorSettings.setRightMarginShown(false);
-    editorSettings.setFoldingOutlineShown(true);
-    editorSettings.setLineNumbersShown(false);
-    editorSettings.setLineMarkerAreaShown(false);
-    editorSettings.setIndentGuidesShown(false);
-    editorSettings.setVirtualSpace(false);
-    editorSettings.setLineCursorWidth(1);
-  }
-
-  public void setUiUpdateRunnable(Runnable uiUpdateRunnable) {
-    assert myUiUpdateRunnable == null : "can be set only once";
-    myUiUpdateRunnable = uiUpdateRunnable;
-  }
-
-  public void flushAllUiUpdates() {
-    myUpdateQueue.flush();
-  }
-
-  public LightVirtualFile getHistoryFile() {
-    return myHistoryFile;
-  }
-
-  public String getPrompt() {
-    return myPrompt;
-  }
-
-  public void setPrompt(String prompt) {
-    myPrompt = prompt;
-    ((EditorImpl)myConsoleEditor).setPrefixTextAndAttributes(myPrompt, ConsoleViewContentType.USER_INPUT.getAttributes());
-  }
-
-  public PsiFile getFile() {
-    return myFile;
-  }
-
-  public EditorEx getHistoryViewer() {
-    return myHistoryViewer;
-  }
-
-  public Document getEditorDocument() {
-    return myEditorDocument;
-  }
-
-  public EditorEx getConsoleEditor() {
-    return myConsoleEditor;
-  }
-
-  public Project getProject() {
-    return myProject;
-  }
-
-  public String getTitle() {
-    return myTitle;
-  }
-
-  public void setTitle(String title) {
-    this.myTitle = title;
-  }
-
-  public void addToHistory(final String text, final TextAttributes attributes) {
-    printToHistory(text, attributes);
-  }
-
-  public Editor getFullEditor() {
-    return myFullEditor;
-  }
-
-  public void printToHistory(String text, final TextAttributes attributes) {
-    text = StringUtil.convertLineSeparators(text);
-    final boolean scrollToEnd = shouldScrollHistoryToEnd();
-    final Document history = myHistoryViewer.getDocument();
-    final MarkupModel markupModel = history.getMarkupModel(myProject);
-    final int offset = history.getTextLength();
-    history.insertString(offset, text);
-    markupModel.addRangeHighlighter(offset,
-                                    history.getTextLength(),
-                                    HighlighterLayer.SYNTAX,
-                                    attributes,
-                                    HighlighterTargetArea.EXACT_RANGE);
-    queueUiUpdate(scrollToEnd);
-  }
-
-  public String addCurrentToHistory(final TextRange textRange, final boolean erase) {
-    final Ref<String> ref = Ref.create("");
-    final boolean scrollToEnd = shouldScrollHistoryToEnd();
-    ApplicationManager.getApplication().runWriteAction(new Runnable() {
-      public void run() {
-        ref.set(addTextRangeToHistory(textRange, myConsoleEditor));
-        if (erase) {
-          myConsoleEditor.getDocument().deleteString(textRange.getStartOffset(), textRange.getEndOffset());
-        }
-      }
-    });
-    queueUiUpdate(scrollToEnd);
-    return ref.get();
-  }
-
-  public boolean shouldScrollHistoryToEnd() {
-    final Rectangle visibleArea = myHistoryViewer.getScrollingModel().getVisibleArea();
-    final int lineNum = (visibleArea.y + visibleArea.height + myHistoryViewer.getLineHeight()) / myHistoryViewer.getLineHeight();
-    final int lineCount = myHistoryViewer.getDocument().getLineCount();
-    return lineNum == lineCount;
-  }
-
-  private void scrollHistoryToEnd() {
-    final int lineCount = myHistoryViewer.getDocument().getLineCount();
-    if (lineCount == 0) return;
-    myHistoryViewer.getCaretModel().moveToOffset(myHistoryViewer.getDocument().getLineStartOffset(lineCount - 1));
-    myHistoryViewer.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
-  }
-
-  private String addTextRangeToHistory(TextRange textRange, final EditorEx consoleEditor) {
-    final DocumentImpl history = (DocumentImpl)myHistoryViewer.getDocument();
-    final MarkupModel markupModel = history.getMarkupModel(myProject);
-    final int promptOffset = history.getTextLength();
-    history.insertString(history.getTextLength(), myPrompt);
-    markupModel.addRangeHighlighter(promptOffset, history.getTextLength(), HighlighterLayer.SYNTAX, ConsoleViewContentType.USER_INPUT.getAttributes(),
-                                    HighlighterTargetArea.EXACT_RANGE);
-
-    final int offset = history.getTextLength();
-    final String text = consoleEditor.getDocument().getText(textRange);
-    history.insertString(offset, text);
-    final HighlighterIterator iterator = consoleEditor.getHighlighter().createIterator(0);
-    while (!iterator.atEnd()) {
-      final int localOffset = textRange.getStartOffset();
-      final int start = Math.max(iterator.getStart(), localOffset) - localOffset;
-      final int end = Math.min(iterator.getEnd(), textRange.getEndOffset()) - localOffset;
-      if (start <= end) {
-        markupModel.addRangeHighlighter(start + offset, end + offset, HighlighterLayer.SYNTAX, iterator.getTextAttributes(),
-                                        HighlighterTargetArea.EXACT_RANGE);
-      }
-      iterator.advance();
-    }
-    if (myDoSaveErrorsToHistory) {
-      duplicateHighlighters(markupModel, consoleEditor.getDocument().getMarkupModel(myProject), offset, textRange);
-      duplicateHighlighters(markupModel, consoleEditor.getMarkupModel(), offset, textRange);
-    }
-    if (!text.endsWith("\n")) history.insertString(history.getTextLength(), "\n");
-    return text;
-  }
-
-  private static void duplicateHighlighters(MarkupModel to, MarkupModel from, int offset, TextRange textRange) {
-    for (RangeHighlighter rangeHighlighter : from.getAllHighlighters()) {
-      final int localOffset = textRange.getStartOffset();
-      final int start = Math.max(rangeHighlighter.getStartOffset(), localOffset) - localOffset;
-      final int end = Math.min(rangeHighlighter.getEndOffset(), textRange.getEndOffset()) - localOffset;
-      if (start > end) continue;
-      final RangeHighlighter h = to.addRangeHighlighter(
-        start + offset, end + offset, rangeHighlighter.getLayer(), rangeHighlighter.getTextAttributes(), rangeHighlighter.getTargetArea());
-      ((RangeHighlighterEx)h).setAfterEndOfLine(((RangeHighlighterEx)rangeHighlighter).isAfterEndOfLine());
-    }
-  }
-
-  public JComponent getComponent() {
-    return myPanel;
-  }
-
-  public void queueUiUpdate(final boolean forceScrollToEnd) {
-    myForceScrollToEnd.compareAndSet(false, forceScrollToEnd);
-    myUpdateQueue.queue(new Update("UpdateUi") {
-      public void run() {
-        if (Disposer.isDisposed(LanguageConsoleImpl.this)) return;
-        updateSizes(myForceScrollToEnd.getAndSet(false));
-        if (myUiUpdateRunnable != null) {
-          ApplicationManager.getApplication().runReadAction(myUiUpdateRunnable);
-        }
-      }
-    });
-  }
-
-  private void updateSizes(boolean forceScrollToEnd) {
-    if (myFullEditor != null) return;
-    final Dimension panelSize = myPanel.getSize();
-    final Dimension historyContentSize = myHistoryViewer.getContentSize();
-    final Dimension contentSize = myConsoleEditor.getContentSize();
-    final Dimension newEditorSize = new Dimension();
-    final int minHistorySize = historyContentSize.height > 0 ? 2 * myHistoryViewer.getLineHeight() + SEPARATOR_THICKNESS : 0;
-    final int width = Math.max(contentSize.width, historyContentSize.width);
-    newEditorSize.height = Math.min(Math.max(panelSize.height - minHistorySize, 2 * myConsoleEditor.getLineHeight()),
-                                    contentSize.height + myConsoleEditor.getScrollPane().getHorizontalScrollBar().getHeight());
-    newEditorSize.width = width + myConsoleEditor.getScrollPane().getHorizontalScrollBar().getHeight();
-    myConsoleEditor.getSettings().setAdditionalColumnsCount(2 + (width - contentSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, myConsoleEditor));
-    myHistoryViewer.getSettings().setAdditionalColumnsCount(2 + (width - historyContentSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, myHistoryViewer));
-
-    final Dimension editorSize = myConsoleEditor.getComponent().getSize();
-    if (!editorSize.equals(newEditorSize)) {
-      myConsoleEditor.getComponent().setPreferredSize(newEditorSize);
-    }
-    final boolean scrollToEnd = forceScrollToEnd || shouldScrollHistoryToEnd();
-    final Dimension newHistorySize = new Dimension(
-      width, Math.max(0, Math.min(minHistorySize == 0? 0 : historyContentSize.height + SEPARATOR_THICKNESS,
-                                  panelSize.height - newEditorSize.height)));
-    final Dimension historySize = myHistoryViewer.getComponent().getSize();
-    if (!historySize.equals(newHistorySize)) {
-      myHistoryViewer.getComponent().setPreferredSize(newHistorySize);
-    }
-    myPanel.validate();
-    if (scrollToEnd) scrollHistoryToEnd();
-  }
-
-  public void dispose() {
-    final EditorFactory editorFactory = EditorFactory.getInstance();
-    editorFactory.releaseEditor(myConsoleEditor);
-    editorFactory.releaseEditor(myHistoryViewer);
-
-    final VirtualFile virtualFile = myFile.getVirtualFile();
-    assert virtualFile != null;
-    final FileEditorManager editorManager = FileEditorManager.getInstance(getProject());
-    final boolean isOpen = editorManager.isFileOpen(virtualFile);
-    if (isOpen) {
-      editorManager.closeFile(virtualFile);
-    }
-  }
-
-  public void calcData(DataKey key, DataSink sink) {
-    if (OpenFileDescriptor.NAVIGATE_IN_EDITOR == key) {
-      sink.put(OpenFileDescriptor.NAVIGATE_IN_EDITOR, myConsoleEditor);
-      return;
-    }
-    final Object o =
-      ((FileEditorManagerImpl)FileEditorManager.getInstance(getProject())).getData(key.getName(), myConsoleEditor, myFile.getVirtualFile());
-    sink.put(key, o);
-  }
-
-  private void installEditorFactoryListener() {
-    final EditorFactoryListener factoryListener = new EditorFactoryListener() {
-      public void editorCreated(final EditorFactoryEvent event) {
-        final Editor editor = event.getEditor();
-        if (editor.getDocument() == myEditorDocument) {
-          if (myConsoleEditor != null) {
-            // i.e. if console is initialized
-            queueUiUpdate(false);
-            registerActionShortcuts(editor.getComponent());
-          }
-          editor.getCaretModel().addCaretListener(new CaretListener() {
-            public void caretPositionChanged(CaretEvent e) {
-              queueUiUpdate(false);
-            }
-          });
-          editor.getContentComponent().addFocusListener(new FocusListener() {
-            public void focusGained(final FocusEvent e) {
-              myCurrentEditor = editor;
-            }
-
-            public void focusLost(final FocusEvent e) {
-            }
-          });
-        }
-      }
-
-      public void editorReleased(final EditorFactoryEvent event) {
-        if (event.getEditor().getDocument() == myEditorDocument) {
-          if (myUiUpdateRunnable != null) {
-            ApplicationManager.getApplication().runReadAction(myUiUpdateRunnable);
-          }
-        }
-      }
-    };
-    EditorFactory.getInstance().addEditorFactoryListener(factoryListener, this);
-  }
-
-  protected void registerActionShortcuts(JComponent component) {
-    final ArrayList<AnAction> actionList = (ArrayList<AnAction>)myConsoleEditor.getComponent().getClientProperty(AnAction.ourClientProperty);
-    if (actionList != null) {
-      for (AnAction anAction : actionList) {
-        anAction.registerCustomShortcutSet(anAction.getShortcutSet(), component);
-      }
-    }
-  }
-
-  public Editor getCurrentEditor() {
-    return myCurrentEditor;
-  }
-
-  public void setLanguage(Language language) {
-    final PsiFile prevFile = myFile;
-    if (prevFile != null) {
-      final VirtualFile file = prevFile.getVirtualFile();
-      assert file instanceof LightVirtualFile;
-      ((LightVirtualFile)file).setValid(false);
-      ((PsiManagerEx)prevFile.getManager()).getFileManager().setViewProvider(file, null);
-    }
-
-    final FileType type = language.getAssociatedFileType();
-    @NonNls final String name = getTitle();
-    final LightVirtualFile newVFile = new LightVirtualFile(name, language, myEditorDocument.getText());
-    FileDocumentManagerImpl.registerDocument(myEditorDocument, newVFile);
-    myFile = ((PsiFileFactoryImpl)PsiFileFactory.getInstance(myProject)).trySetupPsiForFile(newVFile, language, true, false);
-    if (myFile == null) {
-      throw new AssertionError("file=null, name=" + name + ", language=" + language.getDisplayName());
-    }
-    PsiDocumentManagerImpl.cachePsi(myEditorDocument, myFile);
-    FileContentUtil.reparseFiles(myProject, Collections.<VirtualFile>singletonList(newVFile), false);
-
-    if (prevFile != null) {
-      final FileEditorManager editorManager = FileEditorManager.getInstance(getProject());
-      final VirtualFile file = prevFile.getVirtualFile();
-      if (file != null && myFullEditor != null) {
-        myFullEditor = null;
-        final FileEditor prevEditor = editorManager.getSelectedEditor(file);
-        final boolean focusEditor;
-        final int offset;
-        if (prevEditor != null) {
-          offset = prevEditor instanceof TextEditor ? ((TextEditor)prevEditor).getEditor().getCaretModel().getOffset() : 0;
-          final Component owner = FocusManager.getCurrentManager().getFocusOwner();
-          focusEditor = owner != null && SwingUtilities.isDescendingFrom(owner, prevEditor.getComponent());
-        }
-        else {
-          focusEditor = false;
-          offset = 0;
-        }
-        editorManager.closeFile(file);
-        myFullEditor = editorManager.openTextEditor(new OpenFileDescriptor(getProject(), newVFile, offset), focusEditor);
-        configureFullEditor();
-        ((FileEditorManagerEx)editorManager).getCurrentWindow().setFilePinned(newVFile, true);
-      }
-    }
-  }
-
-  private void configureFullEditor() {
-    if (myFullEditor == null || myFullEditorActions == null) return;
-    final JPanel header = new JPanel(new BorderLayout());
-    header.add(ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, myFullEditorActions, true).getComponent(), BorderLayout.EAST);
-    myFullEditor.setHeaderComponent(header);
-    myFullEditor.getSettings().setLineMarkerAreaShown(false);
-  }
-
-  public void setInputText(final String query) {
-    ApplicationManager.getApplication().runWriteAction(new Runnable() {
-      public void run() {
-        myConsoleEditor.getDocument().setText(query);
-      }
-    });
-  }
-
-  public static void printToConsole(final LanguageConsoleImpl console,
-                                    final String string,
-                                    final ConsoleViewContentType mainType,
-                                    ConsoleViewContentType additionalType) {
-    final TextAttributes mainAttributes = mainType.getAttributes();
-    final TextAttributes attributes;
-    if (additionalType == null) {
-      attributes = mainAttributes;
-    } else {
-      attributes = additionalType.getAttributes().clone();
-      attributes.setBackgroundColor(mainAttributes.getBackgroundColor());
-    }
-    ApplicationManager.getApplication().invokeLater(new Runnable() {
-      public void run() {
-        console.printToHistory(string, attributes);
-      }
-    }, ModalityState.stateForComponent(console.getComponent()));
-  }
-}
+/*\r
+ * Copyright 2000-2010 JetBrains s.r.o.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+package com.intellij.execution.console;\r
+\r
+import com.intellij.execution.ui.ConsoleViewContentType;\r
+import com.intellij.ide.DataManager;\r
+import com.intellij.ide.impl.TypeSafeDataProviderAdapter;\r
+import com.intellij.lang.Language;\r
+import com.intellij.openapi.Disposable;\r
+import com.intellij.openapi.actionSystem.*;\r
+import com.intellij.openapi.application.ApplicationManager;\r
+import com.intellij.openapi.application.ModalityState;\r
+import com.intellij.openapi.editor.*;\r
+import com.intellij.openapi.editor.actions.EditorActionUtil;\r
+import com.intellij.openapi.editor.colors.EditorColors;\r
+import com.intellij.openapi.editor.event.*;\r
+import com.intellij.openapi.editor.ex.EditorEx;\r
+import com.intellij.openapi.editor.ex.RangeHighlighterEx;\r
+import com.intellij.openapi.editor.ex.util.EditorUtil;\r
+import com.intellij.openapi.editor.highlighter.EditorHighlighterFactory;\r
+import com.intellij.openapi.editor.highlighter.HighlighterIterator;\r
+import com.intellij.openapi.editor.impl.DocumentImpl;\r
+import com.intellij.openapi.editor.impl.EditorFactoryImpl;\r
+import com.intellij.openapi.editor.impl.EditorImpl;\r
+import com.intellij.openapi.editor.markup.*;\r
+import com.intellij.openapi.fileEditor.FileEditor;\r
+import com.intellij.openapi.fileEditor.FileEditorManager;\r
+import com.intellij.openapi.fileEditor.OpenFileDescriptor;\r
+import com.intellij.openapi.fileEditor.TextEditor;\r
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;\r
+import com.intellij.openapi.fileEditor.impl.EditorWindow;\r
+import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl;\r
+import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl;\r
+import com.intellij.openapi.fileTypes.FileType;\r
+import com.intellij.openapi.fileTypes.StdFileTypes;\r
+import com.intellij.openapi.project.Project;\r
+import com.intellij.openapi.util.Disposer;\r
+import com.intellij.openapi.util.Ref;\r
+import com.intellij.openapi.util.TextRange;\r
+import com.intellij.openapi.util.text.StringUtil;\r
+import com.intellij.openapi.vfs.VirtualFile;\r
+import com.intellij.psi.PsiFile;\r
+import com.intellij.psi.PsiFileFactory;\r
+import com.intellij.psi.impl.PsiDocumentManagerImpl;\r
+import com.intellij.psi.impl.PsiFileFactoryImpl;\r
+import com.intellij.psi.impl.PsiManagerEx;\r
+import com.intellij.testFramework.LightVirtualFile;\r
+import com.intellij.ui.SideBorder;\r
+import com.intellij.util.FileContentUtil;\r
+import com.intellij.util.ui.UIUtil;\r
+import com.intellij.util.ui.update.MergingUpdateQueue;\r
+import com.intellij.util.ui.update.Update;\r
+import org.jetbrains.annotations.NonNls;\r
+\r
+import javax.swing.FocusManager;\r
+import javax.swing.*;\r
+import java.awt.*;\r
+import java.awt.event.*;\r
+import java.util.ArrayList;\r
+import java.util.Collections;\r
+import java.util.concurrent.atomic.AtomicBoolean;\r
+\r
+/**\r
+ * @author Gregory.Shrago\r
+ */\r
+public class LanguageConsoleImpl implements Disposable, TypeSafeDataProvider {\r
+  private static final int SEPARATOR_THICKNESS = 1;\r
+\r
+  private final Project myProject;\r
+\r
+  private final EditorEx myConsoleEditor;\r
+  private final EditorEx myHistoryViewer;\r
+  private final Document myEditorDocument;\r
+  protected PsiFile myFile;\r
+\r
+  private final JPanel myPanel = new JPanel(new BorderLayout());\r
+\r
+  private String myTitle;\r
+  private String myPrompt = "> ";\r
+  private final LightVirtualFile myHistoryFile;\r
+\r
+  private Editor myCurrentEditor;\r
+\r
+  private final AtomicBoolean myForceScrollToEnd = new AtomicBoolean(false);\r
+  private final MergingUpdateQueue myUpdateQueue;\r
+  private Runnable myUiUpdateRunnable;\r
+\r
+  private Editor myFullEditor;\r
+  private ActionGroup myFullEditorActions;\r
+  private final boolean myDoSaveErrorsToHistory;\r
+\r
+  public LanguageConsoleImpl(final Project project, String title, final Language language, final boolean doSaveErrorsToHistory) {\r
+    myProject = project;\r
+    myTitle = title;\r
+    myDoSaveErrorsToHistory = doSaveErrorsToHistory;\r
+    installEditorFactoryListener();\r
+    final EditorFactory editorFactory = EditorFactory.getInstance();\r
+    myHistoryFile = new LightVirtualFile(getTitle() + ".history.txt", StdFileTypes.PLAIN_TEXT, "");\r
+    myEditorDocument = editorFactory.createDocument("");\r
+    setLanguage(language);\r
+    myConsoleEditor = (EditorEx)editorFactory.createEditor(myEditorDocument, myProject);\r
+    myConsoleEditor.setBackgroundColor(myConsoleEditor.getColorsScheme().getColor(ConsoleViewContentType.CONSOLE_BACKGROUND_KEY));\r
+    myCurrentEditor = myConsoleEditor;\r
+    myHistoryViewer = (EditorEx)editorFactory.createViewer(((EditorFactoryImpl)editorFactory).createDocument(true), myProject);\r
+    myHistoryViewer.setBackgroundColor(myHistoryViewer.getColorsScheme().getColor(ConsoleViewContentType.CONSOLE_BACKGROUND_KEY));\r
+    myPanel.add(myHistoryViewer.getComponent(), BorderLayout.NORTH);\r
+    myPanel.add(myConsoleEditor.getComponent(), BorderLayout.CENTER);\r
+    setupComponents();\r
+    myPanel.putClientProperty(DataManager.CLIENT_PROPERTY_DATA_PROVIDER, new TypeSafeDataProviderAdapter(this));\r
+    myUpdateQueue = new MergingUpdateQueue("ConsoleUpdateQueue", 300, true, null);\r
+    Disposer.register(this, myUpdateQueue);\r
+    myPanel.addComponentListener(new ComponentAdapter() {\r
+      public void componentResized(ComponentEvent e) {\r
+        try {\r
+          myHistoryViewer.getScrollingModel().disableAnimation();\r
+          updateSizes(true);\r
+        }\r
+        finally {\r
+          myHistoryViewer.getScrollingModel().enableAnimation();\r
+        }\r
+      }\r
+\r
+      public void componentShown(ComponentEvent e) {\r
+        componentResized(e);\r
+      }\r
+    });\r
+  }\r
+\r
+  public void setFullEditorMode(boolean fullEditorMode) {\r
+    if (myFullEditor != null == fullEditorMode) return;\r
+    final VirtualFile virtualFile = myFile.getVirtualFile();\r
+    assert virtualFile != null;\r
+    final FileEditorManagerEx fileManager = FileEditorManagerEx.getInstanceEx(getProject());\r
+    if (!fullEditorMode) {\r
+      fileManager.closeFile(virtualFile);\r
+      myFullEditor = null;\r
+      myPanel.removeAll();\r
+      myPanel.add(myHistoryViewer.getComponent(), BorderLayout.NORTH);\r
+      myPanel.add(myConsoleEditor.getComponent(), BorderLayout.CENTER);\r
+\r
+      myHistoryViewer.setHorizontalScrollbarVisible(false);\r
+    }\r
+    else {\r
+      myPanel.removeAll();\r
+      myPanel.add(myHistoryViewer.getComponent(), BorderLayout.CENTER);\r
+      myFullEditor = fileManager.openTextEditor(new OpenFileDescriptor(getProject(), virtualFile, 0), true);\r
+      assert myFullEditor != null;\r
+      configureFullEditor();\r
+      EditorWindow editorWindow = EditorWindow.DATA_KEY.getData(DataManager.getInstance().getDataContext(myFullEditor.getComponent()));\r
+      if (editorWindow == null) {\r
+        editorWindow = fileManager.getCurrentWindow();\r
+      }\r
+      if (editorWindow != null) {\r
+        editorWindow.setFilePinned(virtualFile, true);\r
+      }\r
+\r
+      myHistoryViewer.setHorizontalScrollbarVisible(true);\r
+    }\r
+  }\r
+\r
+  public void setFullEditorActions(ActionGroup actionGroup) {\r
+    myFullEditorActions = actionGroup;\r
+    configureFullEditor();\r
+  }\r
+\r
+  private void setupComponents() {\r
+    setupEditorDefault(myConsoleEditor);\r
+    setupEditorDefault(myHistoryViewer);\r
+    setPrompt(myPrompt);\r
+    myConsoleEditor.addEditorMouseListener(EditorActionUtil.createEditorPopupHandler(IdeActions.GROUP_CUT_COPY_PASTE));\r
+    if (SEPARATOR_THICKNESS > 0) {\r
+      myHistoryViewer.getComponent().setBorder(new SideBorder(Color.LIGHT_GRAY, SideBorder.BOTTOM));\r
+    }\r
+    myHistoryViewer.getComponent().setMinimumSize(new Dimension(0, 0));\r
+    myHistoryViewer.getComponent().setPreferredSize(new Dimension(0, 0));\r
+    myConsoleEditor.getSettings().setAdditionalLinesCount(2);\r
+    myConsoleEditor.setHighlighter(EditorHighlighterFactory.getInstance().createEditorHighlighter(myProject, myFile.getVirtualFile()));\r
+    myHistoryViewer.setCaretEnabled(false);\r
+    myConsoleEditor.setHorizontalScrollbarVisible(true);\r
+    final VisibleAreaListener areaListener = new VisibleAreaListener() {\r
+      public void visibleAreaChanged(VisibleAreaEvent e) {\r
+        final int offset = myConsoleEditor.getScrollingModel().getHorizontalScrollOffset();\r
+        final ScrollingModel model = myHistoryViewer.getScrollingModel();\r
+        final int historyOffset = model.getHorizontalScrollOffset();\r
+        if (historyOffset != offset) {\r
+          try {\r
+            model.disableAnimation();\r
+            model.scrollHorizontally(offset);\r
+          }\r
+          finally {\r
+            model.enableAnimation();\r
+          }\r
+        }\r
+      }\r
+    };\r
+    myConsoleEditor.getScrollingModel().addVisibleAreaListener(areaListener);\r
+    final DocumentAdapter docListener = new DocumentAdapter() {\r
+      @Override\r
+      public void documentChanged(final DocumentEvent e) {\r
+        queueUiUpdate(false);\r
+      }\r
+    };\r
+    myEditorDocument.addDocumentListener(docListener, this);\r
+    myHistoryViewer.getDocument().addDocumentListener(docListener, this);\r
+\r
+    myHistoryViewer.getContentComponent().addKeyListener(new KeyAdapter() {\r
+      public void keyTyped(KeyEvent event) {\r
+        if (myFullEditor == null && UIUtil.isReallyTypedEvent(event)) {\r
+          myConsoleEditor.getContentComponent().requestFocus();\r
+          myConsoleEditor.processKeyTyped(event);\r
+        }\r
+      }\r
+    });\r
+    for (AnAction action : createActions()) {\r
+      action.registerCustomShortcutSet(action.getShortcutSet(), myConsoleEditor.getComponent());\r
+    }\r
+    registerActionShortcuts(myHistoryViewer.getComponent());\r
+  }\r
+\r
+  protected AnAction[] createActions() {\r
+    return AnAction.EMPTY_ARRAY;\r
+  }\r
+\r
+  private static void setupEditorDefault(EditorEx editor) {\r
+    editor.getContentComponent().setFocusCycleRoot(false);\r
+    editor.setHorizontalScrollbarVisible(false);\r
+    editor.setVerticalScrollbarVisible(true);\r
+    editor.getColorsScheme().setColor(EditorColors.CARET_ROW_COLOR, null);\r
+    editor.setBorder(null);\r
+    editor.getContentComponent().setFocusCycleRoot(false);\r
+\r
+    final EditorSettings editorSettings = editor.getSettings();\r
+    editorSettings.setAdditionalLinesCount(0);\r
+    editorSettings.setAdditionalColumnsCount(1);\r
+    editorSettings.setRightMarginShown(false);\r
+    editorSettings.setFoldingOutlineShown(true);\r
+    editorSettings.setLineNumbersShown(false);\r
+    editorSettings.setLineMarkerAreaShown(false);\r
+    editorSettings.setIndentGuidesShown(false);\r
+    editorSettings.setVirtualSpace(false);\r
+    editorSettings.setLineCursorWidth(1);\r
+  }\r
+\r
+  public void setUiUpdateRunnable(Runnable uiUpdateRunnable) {\r
+    assert myUiUpdateRunnable == null : "can be set only once";\r
+    myUiUpdateRunnable = uiUpdateRunnable;\r
+  }\r
+\r
+  public void flushAllUiUpdates() {\r
+    myUpdateQueue.flush();\r
+  }\r
+\r
+  public LightVirtualFile getHistoryFile() {\r
+    return myHistoryFile;\r
+  }\r
+\r
+  public String getPrompt() {\r
+    return myPrompt;\r
+  }\r
+\r
+  public void setPrompt(String prompt) {\r
+    myPrompt = prompt;\r
+    ((EditorImpl)myConsoleEditor).setPrefixTextAndAttributes(myPrompt, ConsoleViewContentType.USER_INPUT.getAttributes());\r
+  }\r
+\r
+  public PsiFile getFile() {\r
+    return myFile;\r
+  }\r
+\r
+  public EditorEx getHistoryViewer() {\r
+    return myHistoryViewer;\r
+  }\r
+\r
+  public Document getEditorDocument() {\r
+    return myEditorDocument;\r
+  }\r
+\r
+  public EditorEx getConsoleEditor() {\r
+    return myConsoleEditor;\r
+  }\r
+\r
+  public Project getProject() {\r
+    return myProject;\r
+  }\r
+\r
+  public String getTitle() {\r
+    return myTitle;\r
+  }\r
+\r
+  public void setTitle(String title) {\r
+    this.myTitle = title;\r
+  }\r
+\r
+  public void addToHistory(final String text, final TextAttributes attributes) {\r
+    printToHistory(text, attributes);\r
+  }\r
+\r
+  public Editor getFullEditor() {\r
+    return myFullEditor;\r
+  }\r
+\r
+  public void printToHistory(String text, final TextAttributes attributes) {\r
+    text = StringUtil.convertLineSeparators(text);\r
+    final boolean scrollToEnd = shouldScrollHistoryToEnd();\r
+    final Document history = myHistoryViewer.getDocument();\r
+    final MarkupModel markupModel = history.getMarkupModel(myProject);\r
+    final int offset = history.getTextLength();\r
+    history.insertString(offset, text);\r
+    markupModel.addRangeHighlighter(offset,\r
+                                    history.getTextLength(),\r
+                                    HighlighterLayer.SYNTAX,\r
+                                    attributes,\r
+                                    HighlighterTargetArea.EXACT_RANGE);\r
+    queueUiUpdate(scrollToEnd);\r
+  }\r
+\r
+  public String addCurrentToHistory(final TextRange textRange, final boolean erase) {\r
+    final Ref<String> ref = Ref.create("");\r
+    final boolean scrollToEnd = shouldScrollHistoryToEnd();\r
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {\r
+      public void run() {\r
+        ref.set(addTextRangeToHistory(textRange, myConsoleEditor));\r
+        if (erase) {\r
+          myConsoleEditor.getDocument().deleteString(textRange.getStartOffset(), textRange.getEndOffset());\r
+        }\r
+      }\r
+    });\r
+    queueUiUpdate(scrollToEnd);\r
+    return ref.get();\r
+  }\r
+\r
+  public boolean shouldScrollHistoryToEnd() {\r
+    final Rectangle visibleArea = myHistoryViewer.getScrollingModel().getVisibleArea();\r
+    final int lineNum = (visibleArea.y + visibleArea.height + myHistoryViewer.getLineHeight()) / myHistoryViewer.getLineHeight();\r
+    final int lineCount = myHistoryViewer.getDocument().getLineCount();\r
+    return lineNum == lineCount;\r
+  }\r
+\r
+  private void scrollHistoryToEnd() {\r
+    final int lineCount = myHistoryViewer.getDocument().getLineCount();\r
+    if (lineCount == 0) return;\r
+    myHistoryViewer.getCaretModel().moveToOffset(myHistoryViewer.getDocument().getLineStartOffset(lineCount - 1));\r
+    myHistoryViewer.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);\r
+  }\r
+\r
+  private String addTextRangeToHistory(TextRange textRange, final EditorEx consoleEditor) {\r
+    final DocumentImpl history = (DocumentImpl)myHistoryViewer.getDocument();\r
+    final MarkupModel markupModel = history.getMarkupModel(myProject);\r
+    history.insertString(history.getTextLength(), myPrompt);\r
+    markupModel.addRangeHighlighter(history.getTextLength() - myPrompt.length(), history.getTextLength(), HighlighterLayer.SYNTAX,\r
+                                    ConsoleViewContentType.USER_INPUT.getAttributes(),\r
+                                    HighlighterTargetArea.EXACT_RANGE);\r
+\r
+    int offset = history.getTextLength();\r
+    final String text = consoleEditor.getDocument().getText(textRange);\r
+    history.insertString(offset, text);\r
+    offset = history.getTextLength() - text.length(); //offset can be changed after text trimming after insert due to buffer constraints\r
+    final HighlighterIterator iterator = consoleEditor.getHighlighter().createIterator(0);\r
+    while (!iterator.atEnd()) {\r
+      final int localOffset = textRange.getStartOffset();\r
+      final int start = Math.max(iterator.getStart(), localOffset) - localOffset;\r
+      final int end = Math.min(iterator.getEnd(), textRange.getEndOffset()) - localOffset;\r
+      markupModel.addRangeHighlighter(start + offset, end + offset, HighlighterLayer.SYNTAX, iterator.getTextAttributes(),\r
+                                      HighlighterTargetArea.EXACT_RANGE);\r
+\r
+      iterator.advance();\r
+    }\r
+    if (myDoSaveErrorsToHistory) {\r
+      duplicateHighlighters(markupModel, consoleEditor.getDocument().getMarkupModel(myProject), offset, textRange);\r
+      duplicateHighlighters(markupModel, consoleEditor.getMarkupModel(), offset, textRange);\r
+    }\r
+    if (!text.endsWith("\n")) history.insertString(history.getTextLength(), "\n");\r
+    return text;\r
+  }\r
+\r
+  private static void duplicateHighlighters(MarkupModel to, MarkupModel from, int offset, TextRange textRange) {\r
+    for (RangeHighlighter rangeHighlighter : from.getAllHighlighters()) {\r
+      final int localOffset = textRange.getStartOffset();\r
+      final int start = Math.max(rangeHighlighter.getStartOffset(), localOffset) - localOffset;\r
+      final int end = Math.min(rangeHighlighter.getEndOffset(), textRange.getEndOffset()) - localOffset;\r
+      if (start > end) continue;\r
+      final RangeHighlighter h = to.addRangeHighlighter(\r
+        start + offset, end + offset, rangeHighlighter.getLayer(), rangeHighlighter.getTextAttributes(), rangeHighlighter.getTargetArea());\r
+      ((RangeHighlighterEx)h).setAfterEndOfLine(((RangeHighlighterEx)rangeHighlighter).isAfterEndOfLine());\r
+    }\r
+  }\r
+\r
+  public JComponent getComponent() {\r
+    return myPanel;\r
+  }\r
+\r
+  public void queueUiUpdate(final boolean forceScrollToEnd) {\r
+    myForceScrollToEnd.compareAndSet(false, forceScrollToEnd);\r
+    myUpdateQueue.queue(new Update("UpdateUi") {\r
+      public void run() {\r
+        if (Disposer.isDisposed(LanguageConsoleImpl.this)) return;\r
+        updateSizes(myForceScrollToEnd.getAndSet(false));\r
+        if (myUiUpdateRunnable != null) {\r
+          ApplicationManager.getApplication().runReadAction(myUiUpdateRunnable);\r
+        }\r
+      }\r
+    });\r
+  }\r
+\r
+  private void updateSizes(boolean forceScrollToEnd) {\r
+    if (myFullEditor != null) return;\r
+    final Dimension panelSize = myPanel.getSize();\r
+    final Dimension historyContentSize = myHistoryViewer.getContentSize();\r
+    final Dimension contentSize = myConsoleEditor.getContentSize();\r
+    final Dimension newEditorSize = new Dimension();\r
+    final int minHistorySize = historyContentSize.height > 0 ? 2 * myHistoryViewer.getLineHeight() + SEPARATOR_THICKNESS : 0;\r
+    final int width = Math.max(contentSize.width, historyContentSize.width);\r
+    newEditorSize.height = Math.min(Math.max(panelSize.height - minHistorySize, 2 * myConsoleEditor.getLineHeight()),\r
+                                    contentSize.height + myConsoleEditor.getScrollPane().getHorizontalScrollBar().getHeight());\r
+    newEditorSize.width = width + myConsoleEditor.getScrollPane().getHorizontalScrollBar().getHeight();\r
+    myConsoleEditor.getSettings()\r
+      .setAdditionalColumnsCount(2 + (width - contentSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, myConsoleEditor));\r
+    myHistoryViewer.getSettings()\r
+      .setAdditionalColumnsCount(2 + (width - historyContentSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, myHistoryViewer));\r
+\r
+    final Dimension editorSize = myConsoleEditor.getComponent().getSize();\r
+    if (!editorSize.equals(newEditorSize)) {\r
+      myConsoleEditor.getComponent().setPreferredSize(newEditorSize);\r
+    }\r
+    final boolean scrollToEnd = forceScrollToEnd || shouldScrollHistoryToEnd();\r
+    final Dimension newHistorySize = new Dimension(\r
+      width, Math.max(0, Math.min(minHistorySize == 0 ? 0 : historyContentSize.height + SEPARATOR_THICKNESS,\r
+                                  panelSize.height - newEditorSize.height)));\r
+    final Dimension historySize = myHistoryViewer.getComponent().getSize();\r
+    if (!historySize.equals(newHistorySize)) {\r
+      myHistoryViewer.getComponent().setPreferredSize(newHistorySize);\r
+    }\r
+    myPanel.validate();\r
+    if (scrollToEnd) scrollHistoryToEnd();\r
+  }\r
+\r
+  public void dispose() {\r
+    final EditorFactory editorFactory = EditorFactory.getInstance();\r
+    editorFactory.releaseEditor(myConsoleEditor);\r
+    editorFactory.releaseEditor(myHistoryViewer);\r
+\r
+    final VirtualFile virtualFile = myFile.getVirtualFile();\r
+    assert virtualFile != null;\r
+    final FileEditorManager editorManager = FileEditorManager.getInstance(getProject());\r
+    final boolean isOpen = editorManager.isFileOpen(virtualFile);\r
+    if (isOpen) {\r
+      editorManager.closeFile(virtualFile);\r
+    }\r
+  }\r
+\r
+  public void calcData(DataKey key, DataSink sink) {\r
+    if (OpenFileDescriptor.NAVIGATE_IN_EDITOR == key) {\r
+      sink.put(OpenFileDescriptor.NAVIGATE_IN_EDITOR, myConsoleEditor);\r
+      return;\r
+    }\r
+    final Object o =\r
+      ((FileEditorManagerImpl)FileEditorManager.getInstance(getProject())).getData(key.getName(), myConsoleEditor, myFile.getVirtualFile());\r
+    sink.put(key, o);\r
+  }\r
+\r
+  private void installEditorFactoryListener() {\r
+    final EditorFactoryListener factoryListener = new EditorFactoryListener() {\r
+      public void editorCreated(final EditorFactoryEvent event) {\r
+        final Editor editor = event.getEditor();\r
+        if (editor.getDocument() == myEditorDocument) {\r
+          if (myConsoleEditor != null) {\r
+            // i.e. if console is initialized\r
+            queueUiUpdate(false);\r
+            registerActionShortcuts(editor.getComponent());\r
+          }\r
+          editor.getCaretModel().addCaretListener(new CaretListener() {\r
+            public void caretPositionChanged(CaretEvent e) {\r
+              queueUiUpdate(false);\r
+            }\r
+          });\r
+          editor.getContentComponent().addFocusListener(new FocusListener() {\r
+            public void focusGained(final FocusEvent e) {\r
+              myCurrentEditor = editor;\r
+            }\r
+\r
+            public void focusLost(final FocusEvent e) {\r
+            }\r
+          });\r
+        }\r
+      }\r
+\r
+      public void editorReleased(final EditorFactoryEvent event) {\r
+        if (event.getEditor().getDocument() == myEditorDocument) {\r
+          if (myUiUpdateRunnable != null) {\r
+            ApplicationManager.getApplication().runReadAction(myUiUpdateRunnable);\r
+          }\r
+        }\r
+      }\r
+    };\r
+    EditorFactory.getInstance().addEditorFactoryListener(factoryListener, this);\r
+  }\r
+\r
+  protected void registerActionShortcuts(JComponent component) {\r
+    final ArrayList<AnAction> actionList =\r
+      (ArrayList<AnAction>)myConsoleEditor.getComponent().getClientProperty(AnAction.ourClientProperty);\r
+    if (actionList != null) {\r
+      for (AnAction anAction : actionList) {\r
+        anAction.registerCustomShortcutSet(anAction.getShortcutSet(), component);\r
+      }\r
+    }\r
+  }\r
+\r
+  public Editor getCurrentEditor() {\r
+    return myCurrentEditor;\r
+  }\r
+\r
+  public void setLanguage(Language language) {\r
+    final PsiFile prevFile = myFile;\r
+    if (prevFile != null) {\r
+      final VirtualFile file = prevFile.getVirtualFile();\r
+      assert file instanceof LightVirtualFile;\r
+      ((LightVirtualFile)file).setValid(false);\r
+      ((PsiManagerEx)prevFile.getManager()).getFileManager().setViewProvider(file, null);\r
+    }\r
+\r
+    final FileType type = language.getAssociatedFileType();\r
+    @NonNls final String name = getTitle();\r
+    final LightVirtualFile newVFile = new LightVirtualFile(name, language, myEditorDocument.getText());\r
+    FileDocumentManagerImpl.registerDocument(myEditorDocument, newVFile);\r
+    myFile = ((PsiFileFactoryImpl)PsiFileFactory.getInstance(myProject)).trySetupPsiForFile(newVFile, language, true, false);\r
+    if (myFile == null) {\r
+      throw new AssertionError("file=null, name=" + name + ", language=" + language.getDisplayName());\r
+    }\r
+    PsiDocumentManagerImpl.cachePsi(myEditorDocument, myFile);\r
+    FileContentUtil.reparseFiles(myProject, Collections.<VirtualFile>singletonList(newVFile), false);\r
+\r
+    if (prevFile != null) {\r
+      final FileEditorManager editorManager = FileEditorManager.getInstance(getProject());\r
+      final VirtualFile file = prevFile.getVirtualFile();\r
+      if (file != null && myFullEditor != null) {\r
+        myFullEditor = null;\r
+        final FileEditor prevEditor = editorManager.getSelectedEditor(file);\r
+        final boolean focusEditor;\r
+        final int offset;\r
+        if (prevEditor != null) {\r
+          offset = prevEditor instanceof TextEditor ? ((TextEditor)prevEditor).getEditor().getCaretModel().getOffset() : 0;\r
+          final Component owner = FocusManager.getCurrentManager().getFocusOwner();\r
+          focusEditor = owner != null && SwingUtilities.isDescendingFrom(owner, prevEditor.getComponent());\r
+        }\r
+        else {\r
+          focusEditor = false;\r
+          offset = 0;\r
+        }\r
+        editorManager.closeFile(file);\r
+        myFullEditor = editorManager.openTextEditor(new OpenFileDescriptor(getProject(), newVFile, offset), focusEditor);\r
+        configureFullEditor();\r
+        ((FileEditorManagerEx)editorManager).getCurrentWindow().setFilePinned(newVFile, true);\r
+      }\r
+    }\r
+  }\r
+\r
+  private void configureFullEditor() {\r
+    if (myFullEditor == null || myFullEditorActions == null) return;\r
+    final JPanel header = new JPanel(new BorderLayout());\r
+    header.add(ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, myFullEditorActions, true).getComponent(),\r
+               BorderLayout.EAST);\r
+    myFullEditor.setHeaderComponent(header);\r
+    myFullEditor.getSettings().setLineMarkerAreaShown(false);\r
+  }\r
+\r
+  public void setInputText(final String query) {\r
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {\r
+      public void run() {\r
+        myConsoleEditor.getDocument().setText(query);\r
+      }\r
+    });\r
+  }\r
+\r
+  public static void printToConsole(final LanguageConsoleImpl console,\r
+                                    final String string,\r
+                                    final ConsoleViewContentType mainType,\r
+                                    ConsoleViewContentType additionalType) {\r
+    final TextAttributes mainAttributes = mainType.getAttributes();\r
+    final TextAttributes attributes;\r
+    if (additionalType == null) {\r
+      attributes = mainAttributes;\r
+    }\r
+    else {\r
+      attributes = additionalType.getAttributes().clone();\r
+      attributes.setBackgroundColor(mainAttributes.getBackgroundColor());\r
+    }\r
+    ApplicationManager.getApplication().invokeLater(new Runnable() {\r
+      public void run() {\r
+        console.printToHistory(string, attributes);\r
+      }\r
+    }, ModalityState.stateForComponent(console.getComponent()));\r
+  }\r
+}\r
index dbdd430c84bab705c4d51cc161f156c08792873c..0dd937abc9c2ad3f494ed34c42c011f851f072c7 100644 (file)
@@ -1,86 +1,85 @@
-/*
- * Copyright 2000-2009 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.xdebugger.impl.ui.tree;
-
-import com.intellij.openapi.ui.Messages;
-import com.intellij.ui.SimpleColoredComponent;
-import com.intellij.xdebugger.frame.XValueModifier;
-import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
-import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants;
-import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;
-import org.jetbrains.annotations.NotNull;
-
-import javax.swing.*;
-
-/**
- * @author nik
- */
-public class SetValueInplaceEditor extends XDebuggerTreeInplaceEditor {
-  private final JPanel myEditorPanel;
-  private final XValueModifier myModifier;
-  private final XValueNodeImpl myValueNode;
-
-  public SetValueInplaceEditor(final XValueNodeImpl node, @NotNull final String nodeName) {
-    super(node, "setValue");
-    myValueNode = node;
-    myModifier = myValueNode.getValueContainer().getModifier();
-
-    myEditorPanel = new JPanel();
-    myEditorPanel.setLayout(new BoxLayout(myEditorPanel, BoxLayout.X_AXIS));
-    SimpleColoredComponent nameLabel = new SimpleColoredComponent();
-    nameLabel.setIcon(getNode().getIcon());
-    nameLabel.append(nodeName, XDebuggerUIConstants.VALUE_NAME_ATTRIBUTES);
-
-    myEditorPanel.add(nameLabel);
-
-    myEditorPanel.add(myExpressionEditor.getComponent());
-    final String value = myModifier != null ? myModifier.getInitialValueEditorText() : null;
-    myExpressionEditor.setText(value != null ? value : "");
-    myExpressionEditor.selectAll();
-  }
-
-  protected JComponent createInplaceEditorComponent() {
-    return myEditorPanel;
-  }
-
-  public void doOKAction() {
-    if (myModifier == null) return;
-    
-    myExpressionEditor.saveTextInHistory();
-    final XDebuggerTreeState treeState = XDebuggerTreeState.saveState(myTree);
-    myValueNode.setValueModificationStarted();
-    myModifier.setValue(myExpressionEditor.getText(), new XValueModifier.XModificationCallback() {
-      public void valueModified() {
-        DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {
-          public void run() {
-            myTree.rebuildAndRestore(treeState);
-          }
-        });
-      }
-
-      public void errorOccurred(@NotNull final String errorMessage) {
-        DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {
-          public void run() {
-            myTree.rebuildAndRestore(treeState);
-            //todo[nik] show hint instead
-            Messages.showErrorDialog(myTree, errorMessage);
-          }
-        });
-      }
-    });
-    super.doOKAction();
-  }
-}
+/*\r
+ * Copyright 2000-2009 JetBrains s.r.o.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+package com.intellij.xdebugger.impl.ui.tree;\r
+\r
+import com.intellij.codeInsight.hint.HintManager;\r
+import com.intellij.ui.SimpleColoredComponent;\r
+import com.intellij.xdebugger.frame.XValueModifier;\r
+import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;\r
+import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants;\r
+import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;\r
+import org.jetbrains.annotations.NotNull;\r
+\r
+import javax.swing.*;\r
+\r
+/**\r
+ * @author nik\r
+ */\r
+public class SetValueInplaceEditor extends XDebuggerTreeInplaceEditor {\r
+  private final JPanel myEditorPanel;\r
+  private final XValueModifier myModifier;\r
+  private final XValueNodeImpl myValueNode;\r
+\r
+  public SetValueInplaceEditor(final XValueNodeImpl node, @NotNull final String nodeName) {\r
+    super(node, "setValue");\r
+    myValueNode = node;\r
+    myModifier = myValueNode.getValueContainer().getModifier();\r
+\r
+    myEditorPanel = new JPanel();\r
+    myEditorPanel.setLayout(new BoxLayout(myEditorPanel, BoxLayout.X_AXIS));\r
+    SimpleColoredComponent nameLabel = new SimpleColoredComponent();\r
+    nameLabel.setIcon(getNode().getIcon());\r
+    nameLabel.append(nodeName, XDebuggerUIConstants.VALUE_NAME_ATTRIBUTES);\r
+\r
+    myEditorPanel.add(nameLabel);\r
+\r
+    myEditorPanel.add(myExpressionEditor.getComponent());\r
+    final String value = myModifier != null ? myModifier.getInitialValueEditorText() : null;\r
+    myExpressionEditor.setText(value != null ? value : "");\r
+    myExpressionEditor.selectAll();\r
+  }\r
+\r
+  protected JComponent createInplaceEditorComponent() {\r
+    return myEditorPanel;\r
+  }\r
+\r
+  public void doOKAction() {\r
+    if (myModifier == null) return;\r
+    \r
+    myExpressionEditor.saveTextInHistory();\r
+    final XDebuggerTreeState treeState = XDebuggerTreeState.saveState(myTree);\r
+    myValueNode.setValueModificationStarted();\r
+    myModifier.setValue(myExpressionEditor.getText(), new XValueModifier.XModificationCallback() {\r
+      public void valueModified() {\r
+        DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {\r
+          public void run() {\r
+            myTree.rebuildAndRestore(treeState);\r
+          }\r
+        });\r
+      }\r
+\r
+      public void errorOccurred(@NotNull final String errorMessage) {\r
+        DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {\r
+          public void run() {\r
+            myTree.rebuildAndRestore(treeState);\r
+            HintManager.getInstance().showErrorHint(myExpressionEditor.getEditor(), errorMessage);\r
+          }\r
+        });\r
+      }\r
+    });\r
+    super.doOKAction();\r
+  }\r
+}\r