ade7001fc27949a3a723ea4b3429f81fb1d92589
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / fileEditor / impl / PreviewPanel.java
1 /*
2  * Copyright 2000-2014 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;
17
18 import com.intellij.icons.AllIcons;
19 import com.intellij.ide.ui.UISettings;
20 import com.intellij.openapi.actionSystem.AnAction;
21 import com.intellij.openapi.actionSystem.AnActionEvent;
22 import com.intellij.openapi.application.ApplicationManager;
23 import com.intellij.openapi.fileEditor.FileEditorManager;
24 import com.intellij.openapi.fileEditor.FileEditorManagerListener;
25 import com.intellij.openapi.project.Project;
26 import com.intellij.openapi.util.Key;
27 import com.intellij.openapi.util.text.StringUtil;
28 import com.intellij.openapi.vfs.VirtualFile;
29 import com.intellij.openapi.wm.*;
30 import com.intellij.openapi.wm.impl.ToolWindowImpl;
31 import com.intellij.openapi.wm.impl.content.ToolWindowContentUi;
32 import com.intellij.ui.content.Content;
33 import com.intellij.ui.content.ContentManager;
34 import com.intellij.ui.content.ContentManagerAdapter;
35 import com.intellij.ui.content.ContentManagerEvent;
36 import com.intellij.ui.docking.DockManager;
37 import com.intellij.util.ArrayUtil;
38 import org.jetbrains.annotations.NotNull;
39 import org.jetbrains.annotations.Nullable;
40
41 import javax.swing.*;
42 import java.awt.*;
43 import java.util.ArrayList;
44
45 class PreviewPanel extends JPanel {
46   private static final Key<VirtualFile> FILE_KEY = Key.create("v_file");
47   private static final int HISTORY_LIMIT = 10;
48
49   private final Project myProject;
50   private final FileEditorManagerImpl myManager;
51   private final DockManager myDockManager;
52   private EditorWindow myWindow;
53   private EditorsSplitters myEditorsSplitters;
54   private ArrayList<VirtualFile> myHistory = new ArrayList<VirtualFile>();
55   private VirtualFile myModifiedFile = null;
56   private ToolWindowImpl myToolWindow;
57   private VirtualFile myAwaitingForOpen = null;
58   private ContentManager myContentManager;
59   private Content myStubContent;
60
61   static boolean isAvailable() {
62     return UISettings.getInstance().NAVIGATE_TO_PREVIEW;
63   }
64
65   PreviewPanel(Project project, FileEditorManagerImpl manager, DockManager dockManager) {
66     myProject = project;
67     myManager = manager;
68     myDockManager = dockManager;
69   }
70
71   // package-private API
72
73   EditorWindow getWindow() {
74     initToolWindowIfNeed();
75     return myWindow;
76   }
77
78   boolean hasCurrentFile(@NotNull VirtualFile file) {
79     return file.equals(getCurrentFile());
80   }
81
82   @Nullable
83   VirtualFile getCurrentModifiedFile() {
84     VirtualFile file = getCurrentFile();
85     return file != null && file.equals(myModifiedFile) ? file : null;
86   }
87
88   private void initToolWindowIfNeed() {
89     if (ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW) != null) return;
90
91     myToolWindow = (ToolWindowImpl)ToolWindowManager.getInstance(myProject)
92       .registerToolWindow(ToolWindowId.PREVIEW, this, ToolWindowAnchor.RIGHT, myProject, false);
93     myToolWindow.setIcon(AllIcons.Actions.PreviewDetails);
94     myToolWindow.setContentUiType(ToolWindowContentUiType.COMBO, null);
95     myContentManager = myToolWindow.getContentManager();
96     myStubContent = myContentManager.getContent(0);
97     myContentManager.addContentManagerListener(new ContentManagerAdapter() {
98       @Override
99       public void selectionChanged(ContentManagerEvent event) {
100         final VirtualFile file = event.getContent().getUserData(FILE_KEY);
101         if (event.getOperation() == ContentManagerEvent.ContentOperation.remove && file != null && file.equals(myModifiedFile)) {
102           close(file);
103           return;
104         }
105
106         if (event.getOperation() != ContentManagerEvent.ContentOperation.add) return;
107
108         if (file != null) {
109           event.getContent().setComponent(PreviewPanel.this);//Actually we share the same component between contents
110           if (!file.equals(myWindow.getSelectedFile())) {
111             ApplicationManager.getApplication().invokeLater(new Runnable() {
112               @Override
113               public void run() {
114                 myManager.openFileWithProviders(file, false, myWindow);
115               }
116             });
117           }
118         }
119       }
120     });
121
122     myEditorsSplitters = new MyEditorsSplitters();
123
124     myProject.getMessageBus().connect().subscribe(FileEditorManagerListener.Before.FILE_EDITOR_MANAGER,
125                                                   new FileEditorManagerListener.Before() {
126                                                     @Override
127                                                     public void beforeFileOpened(@NotNull FileEditorManager source,
128                                                                                  @NotNull VirtualFile file) {
129                                                       myAwaitingForOpen = file;
130                                                       VirtualFile currentFile = getCurrentFile();
131                                                       if (currentFile != null &&
132                                                           currentFile.equals(myModifiedFile) &&
133                                                           !currentFile.equals(file)) {
134                                                         close(currentFile);
135                                                       }
136                                                     }
137
138                                                     @Override
139                                                     public void beforeFileClosed(@NotNull FileEditorManager source,
140                                                                                  @NotNull VirtualFile file) {
141                                                       checkStubContent();
142                                                     }
143                                                   });
144     myEditorsSplitters.createCurrentWindow();
145     myWindow = myEditorsSplitters.getCurrentWindow();
146     myWindow.setTabsPlacement(UISettings.TABS_NONE);
147     setLayout(new GridLayout(1, 1));
148     add(myEditorsSplitters);
149     myToolWindow.setTitleActions(new MoveToEditorTabsAction(), new CloseFileAction());
150     myToolWindow.hide(null);
151   }
152
153   @Nullable
154   private VirtualFile getCurrentFile() {
155     VirtualFile[] files = myWindow.getFiles();
156     return files.length == 1 ? files[0] : null;
157   }
158
159   @NotNull
160   private Content addContent(VirtualFile file) {
161     myHistory.add(file);
162     while (myHistory.size() > HISTORY_LIMIT) {
163       myHistory.remove(0);
164     }
165     String title =
166       StringUtil.getShortened(EditorTabbedContainer.calcTabTitle(myProject, file), UISettings.getInstance().EDITOR_TAB_TITLE_LIMIT);
167
168     Content content = myContentManager.getFactory().createContent(this, title, false);
169     content.putUserData(ToolWindow.SHOW_CONTENT_ICON, Boolean.TRUE);
170     content.putUserData(FILE_KEY, file);
171     content.setIcon(file.getFileType().getIcon());
172     content.setPopupIcon(file.getFileType().getIcon());
173
174     myContentManager.addContent(content);
175     checkStubContent();
176     return content;
177   }
178
179   private void setSelected(VirtualFile file) {
180     Content content = getContent(file);
181     if (content == null) {
182       content = addContent(file);
183     }
184     myContentManager.setSelectedContent(content);
185   }
186
187   @Nullable
188   private Content getContent(VirtualFile file) {
189     Content[] contents = myContentManager.getContents();
190     for (Content content : contents) {
191       if (file.equals(content.getUserData(FILE_KEY))) {
192         return content;
193       }
194     }
195     return null;
196   }
197
198   private void checkStubContent() {
199     if (myContentManager.getContents().length == 0) {
200       myToolWindow.getComponent().putClientProperty(ToolWindowContentUi.HIDE_ID_LABEL, "false");
201       myStubContent.setComponent(this);
202       myContentManager.addContent(myStubContent);
203       ApplicationManager.getApplication().invokeLater(new Runnable() {
204         @Override
205         public void run() {
206           if (myContentManager.getIndexOfContent(myStubContent) != -1) {
207             ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW).hide(null);
208           }
209         }
210       });
211     }
212     else if (myContentManager.getContents().length > 1) {
213       myToolWindow.getComponent().putClientProperty(ToolWindowContentUi.HIDE_ID_LABEL, "true");
214       myContentManager.removeContent(myStubContent, false);
215     }
216   }
217
218   private void close(@NotNull VirtualFile file) {
219     myHistory.remove(file);
220     if (ArrayUtil.find(myEditorsSplitters.getOpenFiles(), file) != -1) {
221       myEditorsSplitters.closeFile(file, false);
222     }
223     if (file.equals(myAwaitingForOpen)) {
224       myAwaitingForOpen = null;
225     }
226     if (file.equals(myModifiedFile)) {
227       myModifiedFile = null;
228     }
229     Content content = getContent(file);
230     if (content != null) {
231       myContentManager.removeContent(content, false);
232       checkStubContent();
233     }
234   }
235
236   private class MoveToEditorTabsAction extends AnAction {
237     public MoveToEditorTabsAction() {
238       super(null, "Move to main tabs", AllIcons.Duplicates.SendToTheLeftGrayed);
239     }
240
241     @Override
242     public void actionPerformed(AnActionEvent e) {
243       VirtualFile virtualFile = getCurrentFile();
244       if (virtualFile == null) {
245         return;
246       }
247
248       EditorWindow window = myManager.getCurrentWindow();
249       if (window == null) { //main tab set is still not created, rare situation
250         myManager.getMainSplitters().createCurrentWindow();
251         window = myManager.getCurrentWindow();
252       }
253       myManager.openFileWithProviders(virtualFile, true, window);
254       close(virtualFile);
255       ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW).hide(null);
256     }
257   }
258
259
260   private class CloseFileAction extends AnAction {
261     public CloseFileAction() {
262       super(null, "Close", AllIcons.Actions.Close);
263     }
264
265     @Override
266     public void actionPerformed(AnActionEvent e) {
267       for (VirtualFile file : myHistory.toArray(new VirtualFile[myHistory.size()])) {
268         close(file);
269       }
270     }
271   }
272
273   private class MyEditorsSplitters extends EditorsSplitters {
274     public MyEditorsSplitters() {
275       super(myManager, myDockManager, false);
276     }
277
278     @Override
279     protected void afterFileOpen(VirtualFile file) {
280       if (file.equals(myAwaitingForOpen)) {
281         setSelected(file);
282       }
283       myAwaitingForOpen = null;
284     }
285
286     @Override
287     protected void afterFileClosed(VirtualFile file) {
288       close(file);
289     }
290
291     @Override
292     public void updateFileIcon(@NotNull VirtualFile file) {
293       EditorWithProviderComposite composite = myWindow.findFileComposite(file);
294       if (composite != null && composite.isModified()) {
295         myModifiedFile = file;
296       }
297     }
298
299     @Override
300     public void setTabsPlacement(int tabPlacement) {
301       super.setTabsPlacement(UISettings.TABS_NONE);
302     }
303
304     @Override
305     public boolean isPreview() {
306       return true;
307     }
308   }
309 }