cleanup
[idea/community.git] / 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 }