cleanup
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / fileEditor / ex / FileEditorManagerEx.java
1 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package com.intellij.openapi.fileEditor.ex;
3
4 import com.intellij.openapi.Disposable;
5 import com.intellij.openapi.editor.Caret;
6 import com.intellij.openapi.editor.Editor;
7 import com.intellij.openapi.fileEditor.EditorDataProvider;
8 import com.intellij.openapi.fileEditor.FileEditor;
9 import com.intellij.openapi.fileEditor.FileEditorManager;
10 import com.intellij.openapi.fileEditor.FileEditorProvider;
11 import com.intellij.openapi.fileEditor.impl.EditorComposite;
12 import com.intellij.openapi.fileEditor.impl.EditorWindow;
13 import com.intellij.openapi.fileEditor.impl.EditorsSplitters;
14 import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl;
15 import com.intellij.openapi.fileEditor.impl.text.AsyncEditorLoader;
16 import com.intellij.openapi.project.Project;
17 import com.intellij.openapi.util.ActionCallback;
18 import com.intellij.openapi.util.BusyObject;
19 import com.intellij.openapi.util.Disposer;
20 import com.intellij.openapi.util.Pair;
21 import com.intellij.openapi.vfs.VirtualFile;
22 import org.jetbrains.annotations.NotNull;
23 import org.jetbrains.annotations.Nullable;
24 import org.jetbrains.concurrency.Promise;
25
26 import javax.swing.*;
27 import java.awt.*;
28 import java.util.ArrayList;
29 import java.util.List;
30 import java.util.Set;
31
32 public abstract class FileEditorManagerEx extends FileEditorManager implements BusyObject {
33   private final List<EditorDataProvider> myDataProviders = new ArrayList<>();
34
35   public static FileEditorManagerEx getInstanceEx(@NotNull Project project) {
36     return (FileEditorManagerEx)getInstance(project);
37   }
38
39   /**
40    * @return {@code JComponent} which represent the place where all editors are located
41    */
42   public abstract JComponent getComponent();
43
44   /**
45    * @return preferred focused component inside myEditor tabbed container.
46    * This method does similar things like {@link FileEditor#getPreferredFocusedComponent()}
47    * but it also tracks (and remember) focus movement inside tabbed container.
48    *
49    * @see EditorComposite#getPreferredFocusedComponent()
50    */
51   public abstract @Nullable JComponent getPreferredFocusedComponent();
52
53   public abstract @NotNull Pair<FileEditor[], FileEditorProvider[]> getEditorsWithProviders(@NotNull VirtualFile file);
54
55   public abstract @Nullable VirtualFile getFile(@NotNull FileEditor editor);
56
57   /**
58    * Refreshes the text, colors and icon of the editor tabs representing the specified file.
59    *
60    * @param file the file to refresh.
61    */
62   public abstract void updateFilePresentation(@NotNull VirtualFile file);
63
64   /**
65    * Synchronous version of {@link #getActiveWindow()}. Will return {@code null} if invoked not from EDT.
66    * @return current window in splitters
67    */
68   public abstract EditorWindow getCurrentWindow();
69
70   /**
71    * Asynchronous version of {@link #getCurrentWindow()}. Execution happens after focus settle down. Can be invoked on any thread.
72    */
73   public abstract @NotNull Promise<EditorWindow> getActiveWindow();
74
75   public abstract void setCurrentWindow(EditorWindow window);
76
77   /**
78    * Closes editors for the file opened in particular window.
79    *
80    * @param file file to be closed. Cannot be null.
81    */
82   public abstract void closeFile(@NotNull VirtualFile file, @NotNull EditorWindow window);
83
84   public abstract void unsplitWindow();
85
86   public abstract void unsplitAllWindow();
87
88   public abstract int getWindowSplitCount();
89
90   public abstract boolean hasSplitOrUndockedWindows();
91
92   public abstract EditorWindow @NotNull [] getWindows();
93
94   /**
95    * @return arrays of all files (including {@code file} itself) that belong
96    * to the same tabbed container. The method returns empty array if {@code file}
97    * is not open. The returned files have the same order as they have in the
98    * tabbed container.
99    */
100   public abstract VirtualFile @NotNull [] getSiblings(@NotNull VirtualFile file);
101
102   public abstract void createSplitter(int orientation, @Nullable EditorWindow window);
103
104   public abstract void changeSplitterOrientation();
105
106   public abstract boolean isInSplitter();
107
108   public abstract boolean hasOpenedFile();
109
110   public abstract @Nullable VirtualFile getCurrentFile();
111
112   public abstract @Nullable FileEditorWithProvider getSelectedEditorWithProvider(@NotNull VirtualFile file);
113
114   /**
115    * Closes all files IN ACTIVE SPLITTER (window).
116    *
117    * @see com.intellij.ui.docking.DockManager#getContainers()
118    * @see com.intellij.ui.docking.DockContainer#closeAll()
119    */
120   public abstract void closeAllFiles();
121
122   public abstract @NotNull EditorsSplitters getSplitters();
123
124   @Override
125   public FileEditor @NotNull [] openFile(@NotNull VirtualFile file, boolean focusEditor) {
126     return openFileWithProviders(file, focusEditor, false).getFirst();
127   }
128
129   @Override
130   public FileEditor @NotNull [] openFile(@NotNull VirtualFile file, boolean focusEditor, boolean searchForOpen) {
131     return openFileWithProviders(file, focusEditor, searchForOpen).getFirst();
132   }
133
134   public abstract @NotNull Pair<FileEditor[],FileEditorProvider[]> openFileWithProviders(@NotNull VirtualFile file,
135                                                                                          boolean focusEditor,
136                                                                                          boolean searchForSplitter);
137
138   public abstract @NotNull Pair<FileEditor[],FileEditorProvider[]> openFileWithProviders(@NotNull VirtualFile file,
139                                                                                          boolean focusEditor,
140                                                                                          @NotNull EditorWindow window);
141
142   public abstract boolean isChanged(@NotNull EditorComposite editor);
143
144   public abstract EditorWindow getNextWindow(final @NotNull EditorWindow window);
145
146   public abstract EditorWindow getPrevWindow(final @NotNull EditorWindow window);
147
148   public abstract boolean isInsideChange();
149
150   @Override
151   public final @Nullable Object getData(@NotNull String dataId, @NotNull Editor editor, @NotNull Caret caret) {
152     for (final EditorDataProvider dataProvider : myDataProviders) {
153       final Object o = dataProvider.getData(dataId, editor, caret);
154       if (o != null) return o;
155     }
156     return null;
157   }
158
159   @Override
160   public void registerExtraEditorDataProvider(final @NotNull EditorDataProvider provider, Disposable parentDisposable) {
161     myDataProviders.add(provider);
162     if (parentDisposable != null) {
163       Disposer.register(parentDisposable, () -> myDataProviders.remove(provider));
164     }
165   }
166
167   public void refreshIcons() {
168     if (this instanceof FileEditorManagerImpl) {
169       final FileEditorManagerImpl mgr = (FileEditorManagerImpl)this;
170       Set<EditorsSplitters> splitters = mgr.getAllSplitters();
171       for (EditorsSplitters each : splitters) {
172         for (VirtualFile file : mgr.getOpenFiles()) {
173           each.updateFileIcon(file);
174         }
175       }
176     }
177   }
178
179   public abstract EditorsSplitters getSplittersFor(Component c);
180
181
182   public abstract @NotNull ActionCallback notifyPublisher(@NotNull Runnable runnable);
183
184   @Override
185   public void runWhenLoaded(@NotNull Editor editor, @NotNull Runnable runnable) {
186     AsyncEditorLoader.performWhenLoaded(editor, runnable);
187   }
188 }