import com.intellij.openapi.util.ActionCallback;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.util.registry.Registry;
+import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.util.ui.UIUtil;
import org.jetbrains.annotations.NonNls;
}
}
else if (child instanceof Separator) {
- if (!list.isEmpty() && !(list.get(list.size() - 1) instanceof Separator)) {
+ if (!StringUtil.isEmpty(((Separator)child).getText()) || (!list.isEmpty() && !(list.get(list.size() - 1) instanceof Separator))) {
list.add(child);
}
}
for (int i = 0, size = list.size(); i < size; i++) {
final AnAction action = list.get(i);
if (action instanceof Separator) {
- if (i > 0 && i < size - 1) {
+ final String text = ((Separator)action).getText();
+ if (!StringUtil.isEmpty(text) || (i > 0 && i < size - 1)) {
component.add(new JPopupMenu.Separator() {
+ private final JMenuItem myMenu = !StringUtil.isEmpty(text) ? new JMenuItem(text) : null;
@Override
public Insets getInsets() {
final Insets insets = super.getInsets();
return fix ? new Insets(2, insets.left, 3, insets.right) : insets; // workaround for Sun bug #6636964
}
+ @Override
+ public void doLayout() {
+ super.doLayout();
+ if (myMenu != null) {
+ myMenu.setBounds(getBounds());
+ }
+ }
+
@Override
protected void paintComponent(Graphics g) {
if (UIUtil.isUnderWindowsClassicLookAndFeel() || UIUtil.isUnderDarcula() || UIUtil.isUnderWindowsLookAndFeel()) {
g.setColor(component.getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
}
- super.paintComponent(g);
+ if (myMenu != null) {
+ myMenu.paint(g);
+ } else {
+ super.paintComponent(g);
+ }
+ }
+
+ @Override
+ public Dimension getPreferredSize() {
+ return myMenu != null ? myMenu.getPreferredSize() : super.getPreferredSize();
}
});
}
import com.intellij.openapi.vcs.FileStatusManager;
import com.intellij.openapi.vfs.*;
import com.intellij.openapi.wm.IdeFocusManager;
-import com.intellij.openapi.wm.ToolWindowId;
import com.intellij.openapi.wm.ToolWindowManager;
import com.intellij.openapi.wm.WindowManager;
import com.intellij.openapi.wm.ex.StatusBarEx;
import java.lang.ref.WeakReference;
import java.util.*;
import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author Anton Katilin
private final Project myProject;
private final List<Pair<VirtualFile, EditorWindow>> mySelectionHistory = new ArrayList<Pair<VirtualFile, EditorWindow>>();
private WeakReference<EditorComposite> myLastSelectedComposite = new WeakReference<EditorComposite>(null);
- private final AtomicBoolean myPreviewBlocker = new AtomicBoolean(false);
private final MergingUpdateQueue myQueue = new MergingUpdateQueue("FileEditorManagerUpdateQueue", 50, true, null);
HashSet<EditorsSplitters> all = new LinkedHashSet<EditorsSplitters>();
if (PreviewPanel.isAvailable()) {
initUI();
- if (!myProject.isDisposed()) {
- all.add(myPreviewPanel.getWindow().getOwner());
+ EditorWindow window = myPreviewPanel.getWindow();
+ if (window != null) {
+ all.add(window.getOwner());
}
}
all.add(getMainSplitters());
}
if (wndToOpenIn == null || !wndToOpenIn.isFileOpen(file)) {
- EditorWindow previewWindow = getPreviewWindow(file, focusEditor, searchForSplitter);
+ initUI();
+ EditorWindow previewWindow = myPreviewPanel.getWindow();
if (previewWindow != null) {
wndToOpenIn = previewWindow;
}
return openFileImpl2(wndToOpenIn, file, focusEditor);
}
- @Nullable
- private EditorWindow getPreviewWindow(@NotNull VirtualFile virtualFile, final boolean focusEditor, final boolean searchForSplitter) {
- EditorWindow wndToOpenIn = null;
- if (PreviewPanel.isAvailable() && !myPreviewBlocker.get()) {
- wndToOpenIn = myPreviewPanel.getWindow();
- if (myPreviewPanel.hasCurrentFile(virtualFile)) return wndToOpenIn;
- final VirtualFile modifiedFile = myPreviewPanel.getCurrentModifiedFile();
- ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW).activate(null, false);
- if (modifiedFile != null) {
- CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
- @Override
- public void run() {
- myPreviewBlocker.set(true);
- try {
- openFileWithProviders(modifiedFile, focusEditor, searchForSplitter);
- } finally {
- myPreviewBlocker.set(false);
- }
- }
- }, "", null);
- }
- }
- return wndToOpenIn;
- }
-
public Pair<FileEditor[], FileEditorProvider[]> openFileInNewWindow(@NotNull VirtualFile file) {
return ((DockManagerImpl)DockManager.getInstance(getProject())).createNewDockContainerFor(file, this);
}
import com.intellij.icons.AllIcons;
import com.intellij.ide.ui.UISettings;
+import com.intellij.ide.ui.UISettingsListener;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.DefaultActionGroup;
+import com.intellij.openapi.actionSystem.ToggleAction;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.fileEditor.FileEditorManagerListener;
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
+import java.util.EnumSet;
class PreviewPanel extends JPanel {
+ enum ContentType {Files, Usages, Diagrams, Documentation}
+
private static final Key<VirtualFile> FILE_KEY = Key.create("v_file");
private static final int HISTORY_LIMIT = 10;
private VirtualFile myAwaitingForOpen = null;
private ContentManager myContentManager;
private Content myStubContent;
+ private boolean myBlocked = false;
+
+ private EnumSet<ContentType> myTypes = EnumSet.noneOf(ContentType.class);
static boolean isAvailable() {
return UISettings.getInstance().NAVIGATE_TO_PREVIEW;
myDockManager = dockManager;
}
- // package-private API
-
+ /*
+ * @return null if preview is not avalable
+ */
+ @Nullable
EditorWindow getWindow() {
+ if (!isAvailable() || isBlocked() || myProject.isDisposed()) return null;
initToolWindowIfNeed();
return myWindow;
}
- boolean hasCurrentFile(@NotNull VirtualFile file) {
- return file.equals(getCurrentFile());
- }
-
- @Nullable
- VirtualFile getCurrentModifiedFile() {
- VirtualFile file = getCurrentFile();
- return file != null && file.equals(myModifiedFile) ? file : null;
+ boolean isBlocked() {
+ return myBlocked;
}
private void initToolWindowIfNeed() {
- if (ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW) != null) return;
+ if (!isAvailable() || ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW) != null) return;
myToolWindow = (ToolWindowImpl)ToolWindowManager.getInstance(myProject)
.registerToolWindow(ToolWindowId.PREVIEW, this, ToolWindowAnchor.RIGHT, myProject, false);
+ UISettings.getInstance().addUISettingsListener(new UISettingsListener() {
+ @Override
+ public void uiSettingsChanged(UISettings source) {
+ if (!isAvailable()) {
+ VirtualFile[] files = myWindow.getFiles();
+ for (VirtualFile file : files) {
+ close(file);
+ }
+ ToolWindowManager.getInstance(myProject).unregisterToolWindow(ToolWindowId.PREVIEW);
+ }
+ }
+ }, myProject);
myToolWindow.setIcon(AllIcons.Actions.PreviewDetails);
myToolWindow.setContentUiType(ToolWindowContentUiType.COMBO, null);
myContentManager = myToolWindow.getContentManager();
setLayout(new GridLayout(1, 1));
add(myEditorsSplitters);
myToolWindow.setTitleActions(new MoveToEditorTabsAction(), new CloseFileAction());
+ ArrayList<AnAction> myGearActions = new ArrayList<AnAction>();
+ for (ContentType contentType : ContentType.values()) {
+ myGearActions.add(new ContentTypeToggleAction(contentType));
+ }
+ myToolWindow.setAdditionalGearActions(new DefaultActionGroup("Preview", myGearActions));
myToolWindow.hide(null);
}
@Override
public void run() {
if (myContentManager.getIndexOfContent(myStubContent) != -1) {
- ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW).hide(null);
+ toggleToolWindow(false);
}
}
});
myAwaitingForOpen = null;
}
if (file.equals(myModifiedFile)) {
+ myBlocked = true;
+ try {
+ myManager.openFileWithProviders(myModifiedFile, false, true);
+ }
+ finally {
+ myBlocked = false;
+ }
myModifiedFile = null;
}
Content content = getContent(file);
}
}
+ private void toggleToolWindow(boolean activate) {
+ ToolWindow toolWindow = ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW);
+ if (toolWindow != null) {
+ if (activate) {
+ toolWindow.activate(null, false);
+ }
+ else {
+ toolWindow.hide(null);
+ }
+ }
+ }
+
private class MoveToEditorTabsAction extends AnAction {
+
public MoveToEditorTabsAction() {
- super(null, "Move to main tabs", AllIcons.Duplicates.SendToTheLeftGrayed);
+ super("Move to main tabs", "Move to main tabs", AllIcons.Duplicates.SendToTheLeftGrayed);
}
@Override
}
myManager.openFileWithProviders(virtualFile, true, window);
close(virtualFile);
- ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PREVIEW).hide(null);
+ toggleToolWindow(false);
}
}
private class CloseFileAction extends AnAction {
public CloseFileAction() {
- super(null, "Close", AllIcons.Actions.Close);
+ super("Close", "Close", AllIcons.Actions.Close);
}
@Override
for (VirtualFile file : myHistory.toArray(new VirtualFile[myHistory.size()])) {
close(file);
}
+ toggleToolWindow(false);
+ }
+ }
+
+ private class ContentTypeToggleAction extends ToggleAction {
+ private final ContentType myContentType;
+
+ ContentTypeToggleAction(ContentType contentType) {
+ super(contentType.toString());
+ myContentType = contentType;
+ }
+
+ @Override
+ public boolean isSelected(AnActionEvent e) {
+ return myTypes.contains(myContentType);
+ }
+
+ @Override
+ public void setSelected(AnActionEvent e, boolean state) {
+ if (state) {
+ myTypes.add(myContentType);
+ } else {
+ myTypes.remove(myContentType);
+ }
}
}
}
}
+ @Override
+ protected EditorWindow createEditorWindow() {
+ return new EditorWindow(this) {
+ @Override
+ protected void onBeforeSetEditor(VirtualFile file) {
+ VirtualFile currentFile = getCurrentFile();
+ if (currentFile != null && currentFile.equals(myModifiedFile)) {
+ myBlocked = true;
+ try {
+ myManager.openFileWithProviders(myModifiedFile, false, true);
+ }
+ finally {
+ myBlocked = false;
+ }
+ }
+ else {
+ toggleToolWindow(true);
+ }
+ }
+ };
+ }
+
@Override
public void setTabsPlacement(int tabPlacement) {
super.setTabsPlacement(UISettings.TABS_NONE);