platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorProvider.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.openapi.fileEditor.impl.text;
  17
  18 import com.intellij.codeHighlighting.BackgroundEditorHighlighter;
  19 import com.intellij.ide.structureView.StructureViewBuilder;
  20 import com.intellij.openapi.application.ApplicationManager;
  21 import com.intellij.openapi.diagnostic.Logger;
  22 import com.intellij.openapi.editor.Document;
  23 import com.intellij.openapi.editor.Editor;
  24 import com.intellij.openapi.editor.LogicalPosition;
  25 import com.intellij.openapi.editor.ScrollType;
  26 import com.intellij.openapi.editor.ex.EditorEx;
  27 import com.intellij.openapi.editor.ex.util.EditorUtil;
  28 import com.intellij.openapi.fileEditor.*;
  29 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
  30 import com.intellij.openapi.fileTypes.BinaryFileTypeDecompilers;
  31 import com.intellij.openapi.fileTypes.FileType;
  32 import com.intellij.openapi.project.DumbAware;
  33 import com.intellij.openapi.project.Project;
  34 import com.intellij.openapi.project.ProjectManager;
  35 import com.intellij.openapi.util.Disposer;
  36 import com.intellij.openapi.util.Key;
  37 import com.intellij.openapi.util.UserDataHolderBase;
  38 import com.intellij.openapi.vfs.VirtualFile;
  39 import com.intellij.pom.Navigatable;
  40 import org.jdom.Element;
  41 import org.jetbrains.annotations.NonNls;
  42 import org.jetbrains.annotations.NotNull;
  43 import org.jetbrains.annotations.Nullable;
  44
  45 import javax.swing.*;
  46 import java.beans.PropertyChangeListener;
  47
  48 /**
  49  * @author Anton Katilin
  50  * @author Vladimir Kondratyev
  51  */
  52 public class TextEditorProvider implements FileEditorProvider, DumbAware {
  53   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.fileEditor.impl.text.TextEditorProvider");
  54   private static final Key<TextEditor> TEXT_EDITOR_KEY = Key.create("textEditor");
  55
  56   @NonNls private static final String TYPE_ID = "text-editor";
  57   @NonNls private static final String LINE_ATTR = "line";
  58   @NonNls private static final String COLUMN_ATTR = "column";
  59   @NonNls private static final String SELECTION_START_ATTR = "selection-start";
  60   @NonNls private static final String SELECTION_END_ATTR = "selection-end";
  61   @NonNls private static final String VERTICAL_SCROLL_PROPORTION_ATTR = "vertical-scroll-proportion";
  62
  63   public static TextEditorProvider getInstance() {
  64     return ApplicationManager.getApplication().getComponent(TextEditorProvider.class);
  65   }
  66
  67   public boolean accept(@NotNull Project project, @NotNull VirtualFile file) {
  68     if (file.isDirectory() || !file.isValid()) {
  69       return false;
  70     }
  71
  72     final FileType ft = file.getFileType();
  73     return !ft.isBinary() || BinaryFileTypeDecompilers.INSTANCE.forFileType(ft) != null;
  74   }
  75
  76   @NotNull
  77   public FileEditor createEditor(@NotNull Project project, @NotNull final VirtualFile file) {
  78     LOG.assertTrue(accept(project, file));
  79     return new TextEditorImpl(project, file, this);
  80   }
  81
  82   public void disposeEditor(@NotNull FileEditor editor) {
  83     Disposer.dispose(editor);
  84   }
  85
  86   @NotNull
  87   public FileEditorState readState(@NotNull Element element, @NotNull Project project, @NotNull VirtualFile file) {
  88     TextEditorState state = new TextEditorState();
  89
  90     try {
  91       state.LINE = Integer.parseInt(element.getAttributeValue(LINE_ATTR));
  92       state.COLUMN = Integer.parseInt(element.getAttributeValue(COLUMN_ATTR));
  93       state.SELECTION_START = Integer.parseInt(element.getAttributeValue(SELECTION_START_ATTR));
  94       state.SELECTION_END = Integer.parseInt(element.getAttributeValue(SELECTION_END_ATTR));
  95       state.VERTICAL_SCROLL_PROPORTION = Float.parseFloat(element.getAttributeValue(VERTICAL_SCROLL_PROPORTION_ATTR));
  96     }
  97     catch (NumberFormatException ignored) {
  98     }
  99
 100     return state;
 101   }
 102
 103   public void writeState(@NotNull FileEditorState _state, @NotNull Project project, @NotNull Element element) {
 104     TextEditorState state = (TextEditorState)_state;
 105
 106     element.setAttribute(LINE_ATTR, Integer.toString(state.LINE));
 107     element.setAttribute(COLUMN_ATTR, Integer.toString(state.COLUMN));
 108     element.setAttribute(SELECTION_START_ATTR, Integer.toString(state.SELECTION_START));
 109     element.setAttribute(SELECTION_END_ATTR, Integer.toString(state.SELECTION_END));
 110     element.setAttribute(VERTICAL_SCROLL_PROPORTION_ATTR, Float.toString(state.VERTICAL_SCROLL_PROPORTION));
 111   }
 112
 113   @NotNull
 114   public String getEditorTypeId() {
 115     return TYPE_ID;
 116   }
 117
 118   @NotNull
 119   public FileEditorPolicy getPolicy() {
 120     return FileEditorPolicy.NONE;
 121   }
 122
 123   @NotNull public TextEditor getTextEditor(@NotNull Editor editor) {
 124     TextEditor textEditor = editor.getUserData(TEXT_EDITOR_KEY);
 125     if (textEditor == null) {
 126       textEditor = createWrapperForEditor(editor);
 127       putTextEditor(editor, textEditor);
 128     }
 129
 130     return textEditor;
 131   }
 132
 133   protected EditorWrapper createWrapperForEditor(final Editor editor) {
 134     return new EditorWrapper(editor);
 135   }
 136
 137   @Nullable
 138   public static Document[] getDocuments(@NotNull FileEditor editor) {
 139     if (editor instanceof DocumentsEditor) {
 140       DocumentsEditor documentsEditor = (DocumentsEditor)editor;
 141       Document[] documents = documentsEditor.getDocuments();
 142       return documents.length > 0 ? documents : null;
 143     }
 144
 145     if (editor instanceof TextEditor) {
 146       Document document = ((TextEditor)editor).getEditor().getDocument();
 147       return new Document[]{document};
 148     }
 149
 150     Project[] projects = ProjectManager.getInstance().getOpenProjects();
 151     for (int i = projects.length - 1; i >= 0; i--) {
 152       VirtualFile file = FileEditorManagerEx.getInstanceEx(projects[i]).getFile(editor);
 153       if (file != null) {
 154         Document document = FileDocumentManager.getInstance().getDocument(file);
 155         if (document != null) {
 156           return new Document[]{document};
 157         }
 158       }
 159     }
 160
 161     return null;
 162   }
 163
 164   static void putTextEditor(Editor editor, TextEditor textEditor) {
 165     editor.putUserData(TEXT_EDITOR_KEY, textEditor);
 166   }
 167
 168   protected TextEditorState getStateImpl(final Project project, final Editor editor, @NotNull FileEditorStateLevel level){
 169     TextEditorState state = new TextEditorState();
 170     state.LINE = editor.getCaretModel().getLogicalPosition().line;
 171     state.COLUMN = editor.getCaretModel().getLogicalPosition().column;
 172     state.SELECTION_START = editor.getSelectionModel().getSelectionStart();
 173     state.SELECTION_END = editor.getSelectionModel().getSelectionEnd();
 174
 175     // Saving scrolling proportion on UNDO may cause undesirable results of undo action fails to perform since
 176     // scrolling proportion restored slightly differs from what have been saved.
 177     state.VERTICAL_SCROLL_PROPORTION = level == FileEditorStateLevel.UNDO ? -1 : EditorUtil.calcVerticalScrollProportion(editor);
 178     return state;
 179   }
 180
 181   protected void setStateImpl(final Project project, final Editor editor, final TextEditorState state){
 182     LogicalPosition pos = new LogicalPosition(state.LINE, state.COLUMN);
 183     editor.getCaretModel().moveToLogicalPosition(pos);
 184     editor.getSelectionModel().removeSelection();
 185     editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
 186
 187     if (state.VERTICAL_SCROLL_PROPORTION != -1) {
 188       EditorUtil.setVerticalScrollProportion(editor, state.VERTICAL_SCROLL_PROPORTION);
 189     }
 190
 191     final Document document = editor.getDocument();
 192
 193     if (state.SELECTION_START == state.SELECTION_END) {
 194       editor.getSelectionModel().removeSelection();
 195     }
 196     else {
 197       int startOffset = Math.min(state.SELECTION_START, document.getTextLength());
 198       int endOffset = Math.min(state.SELECTION_END, document.getTextLength());
 199       editor.getSelectionModel().setSelection(startOffset, endOffset);
 200     }
 201     ((EditorEx) editor).stopOptimizedScrolling();
 202     editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
 203   }
 204
 205   protected class EditorWrapper extends UserDataHolderBase implements TextEditor {
 206     private final Editor myEditor;
 207
 208     public EditorWrapper(Editor editor) {
 209       myEditor = editor;
 210     }
 211
 212     @NotNull
 213     public Editor getEditor() {
 214       return myEditor;
 215     }
 216
 217     @NotNull
 218     public JComponent getComponent() {
 219       return myEditor.getComponent();
 220     }
 221
 222     public JComponent getPreferredFocusedComponent() {
 223       return myEditor.getContentComponent();
 224     }
 225
 226     @NotNull
 227     public String getName() {
 228       return "Text";
 229     }
 230
 231     public StructureViewBuilder getStructureViewBuilder() {
 232       VirtualFile file = FileDocumentManager.getInstance().getFile(myEditor.getDocument());
 233       if (file == null) return null;
 234
 235       final Project project = myEditor.getProject();
 236       LOG.assertTrue(project != null);
 237       return StructureViewBuilder.PROVIDER.getStructureViewBuilder(file.getFileType(), file, project);
 238     }
 239
 240     @NotNull
 241     public FileEditorState getState(@NotNull FileEditorStateLevel level) {
 242       return getStateImpl(null, myEditor, level);
 243     }
 244
 245     public void setState(@NotNull FileEditorState state) {
 246       setStateImpl(null, myEditor, (TextEditorState)state);
 247     }
 248
 249     public boolean isModified() {
 250       return false;
 251     }
 252
 253     public boolean isValid() {
 254       return true;
 255     }
 256
 257     public void dispose() { }
 258
 259     public void selectNotify() { }
 260
 261     public void deselectNotify() { }
 262
 263     public void addPropertyChangeListener(@NotNull PropertyChangeListener listener) { }
 264
 265     public void removePropertyChangeListener(@NotNull PropertyChangeListener listener) { }
 266
 267     public BackgroundEditorHighlighter getBackgroundHighlighter() {
 268       return null;
 269     }
 270
 271     public FileEditorLocation getCurrentLocation() {
 272       return null;
 273     }
 274
 275     public boolean canNavigateTo(@NotNull final Navigatable navigatable) {
 276       return false;
 277     }
 278
 279     public void navigateTo(@NotNull final Navigatable navigatable) {
 280     }
 281   }
 282 }