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
 124   public TextEditor getTextEditor(@NotNull Editor editor) {
 125     TextEditor textEditor = editor.getUserData(TEXT_EDITOR_KEY);
 126     if (textEditor == null) {
 127       textEditor = createWrapperForEditor(editor);
 128       putTextEditor(editor, textEditor);
 129     }
 130
 131     return textEditor;
 132   }
 133
 134   protected EditorWrapper createWrapperForEditor(final Editor editor) {
 135     return new EditorWrapper(editor);
 136   }
 137
 138   @Nullable
 139   public static Document[] getDocuments(@NotNull FileEditor editor) {
 140     if (editor instanceof DocumentsEditor) {
 141       DocumentsEditor documentsEditor = (DocumentsEditor)editor;
 142       Document[] documents = documentsEditor.getDocuments();
 143       return documents.length > 0 ? documents : null;
 144     }
 145
 146     if (editor instanceof TextEditor) {
 147       Document document = ((TextEditor)editor).getEditor().getDocument();
 148       return new Document[]{document};
 149     }
 150
 151     Project[] projects = ProjectManager.getInstance().getOpenProjects();
 152     for (int i = projects.length - 1; i >= 0; i--) {
 153       VirtualFile file = FileEditorManagerEx.getInstanceEx(projects[i]).getFile(editor);
 154       if (file != null) {
 155         Document document = FileDocumentManager.getInstance().getDocument(file);
 156         if (document != null) {
 157           return new Document[]{document};
 158         }
 159       }
 160     }
 161
 162     return null;
 163   }
 164
 165   static void putTextEditor(Editor editor, TextEditor textEditor) {
 166     editor.putUserData(TEXT_EDITOR_KEY, textEditor);
 167   }
 168
 169   protected TextEditorState getStateImpl(final Project project, final Editor editor, @NotNull FileEditorStateLevel level){
 170     TextEditorState state = new TextEditorState();
 171     state.LINE = editor.getCaretModel().getLogicalPosition().line;
 172     state.COLUMN = editor.getCaretModel().getLogicalPosition().column;
 173     state.SELECTION_START = editor.getSelectionModel().getSelectionStart();
 174     state.SELECTION_END = editor.getSelectionModel().getSelectionEnd();
 175
 176     // Saving scrolling proportion on UNDO may cause undesirable results of undo action fails to perform since
 177     // scrolling proportion restored slightly differs from what have been saved.
 178     state.VERTICAL_SCROLL_PROPORTION = level == FileEditorStateLevel.UNDO ? -1 : EditorUtil.calcVerticalScrollProportion(editor);
 179     return state;
 180   }
 181
 182   protected void setStateImpl(final Project project, final Editor editor, final TextEditorState state){
 183     LogicalPosition pos = new LogicalPosition(state.LINE, state.COLUMN);
 184     editor.getCaretModel().moveToLogicalPosition(pos);
 185     editor.getSelectionModel().removeSelection();
 186     editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
 187
 188     if (state.VERTICAL_SCROLL_PROPORTION != -1) {
 189       EditorUtil.setVerticalScrollProportion(editor, state.VERTICAL_SCROLL_PROPORTION);
 190     }
 191
 192     final Document document = editor.getDocument();
 193
 194     if (state.SELECTION_START == state.SELECTION_END) {
 195       editor.getSelectionModel().removeSelection();
 196     }
 197     else {
 198       int startOffset = Math.min(state.SELECTION_START, document.getTextLength());
 199       int endOffset = Math.min(state.SELECTION_END, document.getTextLength());
 200       editor.getSelectionModel().setSelection(startOffset, endOffset);
 201     }
 202     ((EditorEx) editor).stopOptimizedScrolling();
 203     editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
 204   }
 205
 206   protected class EditorWrapper extends UserDataHolderBase implements TextEditor {
 207     private final Editor myEditor;
 208
 209     public EditorWrapper(Editor editor) {
 210       myEditor = editor;
 211     }
 212
 213     @NotNull
 214     public Editor getEditor() {
 215       return myEditor;
 216     }
 217
 218     @NotNull
 219     public JComponent getComponent() {
 220       return myEditor.getComponent();
 221     }
 222
 223     public JComponent getPreferredFocusedComponent() {
 224       return myEditor.getContentComponent();
 225     }
 226
 227     @NotNull
 228     public String getName() {
 229       return "Text";
 230     }
 231
 232     public StructureViewBuilder getStructureViewBuilder() {
 233       VirtualFile file = FileDocumentManager.getInstance().getFile(myEditor.getDocument());
 234       if (file == null) return null;
 235
 236       final Project project = myEditor.getProject();
 237       LOG.assertTrue(project != null);
 238       return StructureViewBuilder.PROVIDER.getStructureViewBuilder(file.getFileType(), file, project);
 239     }
 240
 241     @NotNull
 242     public FileEditorState getState(@NotNull FileEditorStateLevel level) {
 243       return getStateImpl(null, myEditor, level);
 244     }
 245
 246     public void setState(@NotNull FileEditorState state) {
 247       setStateImpl(null, myEditor, (TextEditorState)state);
 248     }
 249
 250     public boolean isModified() {
 251       return false;
 252     }
 253
 254     public boolean isValid() {
 255       return true;
 256     }
 257
 258     public void dispose() { }
 259
 260     public void selectNotify() { }
 261
 262     public void deselectNotify() { }
 263
 264     public void addPropertyChangeListener(@NotNull PropertyChangeListener listener) { }
 265
 266     public void removePropertyChangeListener(@NotNull PropertyChangeListener listener) { }
 267
 268     public BackgroundEditorHighlighter getBackgroundHighlighter() {
 269       return null;
 270     }
 271
 272     public FileEditorLocation getCurrentLocation() {
 273       return null;
 274     }
 275
 276     public boolean canNavigateTo(@NotNull final Navigatable navigatable) {
 277       return false;
 278     }
 279
 280     public void navigateTo(@NotNull final Navigatable navigatable) {
 281     }
 282   }
 283 }