| package org.jetbrains.plugins.terminal; |
| |
| import com.google.common.base.Predicate; |
| import com.intellij.ide.dnd.DnDDropHandler; |
| import com.intellij.ide.dnd.DnDEvent; |
| import com.intellij.ide.dnd.DnDSupport; |
| import com.intellij.ide.dnd.TransferableWrapper; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.actionSystem.ActionManager; |
| import com.intellij.openapi.actionSystem.AnAction; |
| import com.intellij.openapi.actionSystem.AnActionEvent; |
| import com.intellij.openapi.actionSystem.Presentation; |
| import com.intellij.openapi.fileEditor.impl.EditorTabbedContainer; |
| import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl; |
| import com.intellij.openapi.project.DumbAwareAction; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.Disposer; |
| import com.intellij.openapi.util.Pair; |
| import com.intellij.openapi.wm.IdeFocusManager; |
| import com.intellij.psi.PsiDirectory; |
| import com.intellij.psi.PsiFile; |
| import com.intellij.psi.PsiFileSystemItem; |
| import com.intellij.ui.SimpleColoredComponent; |
| import com.intellij.ui.components.JBTextField; |
| import com.intellij.ui.docking.DockManager; |
| import com.intellij.ui.docking.DragSession; |
| import com.intellij.ui.tabs.TabInfo; |
| import com.intellij.ui.tabs.TabsListener; |
| import com.intellij.ui.tabs.impl.JBEditorTabs; |
| import com.intellij.ui.tabs.impl.JBTabsImpl; |
| import com.intellij.ui.tabs.impl.TabLabel; |
| import com.intellij.util.ui.UIUtil; |
| import com.jediterm.terminal.ui.*; |
| import com.jediterm.terminal.ui.settings.SettingsProvider; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| import org.jetbrains.plugins.terminal.vfs.TerminalSessionVirtualFileImpl; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.util.List; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| |
| /** |
| * @author traff |
| */ |
| public class JBTabbedTerminalWidget extends TabbedTerminalWidget implements Disposable { |
| |
| private Project myProject; |
| private final JBTerminalSystemSettingsProvider mySettingsProvider; |
| private Disposable myParent; |
| |
| public JBTabbedTerminalWidget(@NotNull Project project, |
| @NotNull JBTerminalSystemSettingsProvider settingsProvider, |
| final @NotNull Predicate<Pair<TerminalWidget, String>> createNewSessionAction, @NotNull Disposable parent) { |
| super(settingsProvider, new Predicate<TerminalWidget>() { |
| @Override |
| public boolean apply(TerminalWidget input) { |
| return createNewSessionAction.apply(Pair.<TerminalWidget, String>create(input, null)); |
| } |
| }); |
| myProject = project; |
| |
| mySettingsProvider = settingsProvider; |
| myParent = parent; |
| |
| convertActions(this, getActions()); |
| |
| Disposer.register(parent, this); |
| Disposer.register(this, settingsProvider); |
| |
| DnDSupport.createBuilder(this).setDropHandler(new DnDDropHandler() { |
| @Override |
| public void drop(DnDEvent event) { |
| if (event.getAttachedObject() instanceof TransferableWrapper) { |
| TransferableWrapper ao = (TransferableWrapper)event.getAttachedObject(); |
| if (ao != null && |
| ao.getPsiElements() != null && |
| ao.getPsiElements().length == 1 && |
| ao.getPsiElements()[0] instanceof PsiFileSystemItem) { |
| PsiFileSystemItem element = (PsiFileSystemItem)ao.getPsiElements()[0]; |
| PsiDirectory dir = element instanceof PsiFile ? ((PsiFile)element).getContainingDirectory() : (PsiDirectory)element; |
| |
| createNewSessionAction.apply(Pair.<TerminalWidget, String>create(JBTabbedTerminalWidget.this, dir.getVirtualFile().getPath())); |
| } |
| } |
| } |
| } |
| |
| ).install(); |
| } |
| |
| public static void convertActions(@NotNull JComponent component, |
| @NotNull List<TerminalAction> actions) { |
| convertActions(component, actions, null); |
| } |
| |
| public static void convertActions(@NotNull JComponent component, |
| @NotNull List<TerminalAction> actions, |
| @Nullable final Predicate<KeyEvent> elseAction) { |
| for (final TerminalAction action : actions) { |
| AnAction a = new DumbAwareAction() { |
| @Override |
| public void actionPerformed(AnActionEvent e) { |
| KeyEvent event = e.getInputEvent() instanceof KeyEvent ? (KeyEvent)e.getInputEvent() : null; |
| if (!action.perform(event)) { |
| if (elseAction != null) { |
| elseAction.apply(event); |
| } |
| } |
| } |
| }; |
| a.registerCustomShortcutSet(action.getKeyCode(), action.getModifiers(), component); |
| } |
| } |
| |
| @Override |
| protected JediTermWidget createInnerTerminalWidget(SettingsProvider settingsProvider) { |
| return new JBTerminalWidget(mySettingsProvider, myParent); |
| } |
| |
| @Override |
| protected TerminalTabs createTabbedPane() { |
| return new JBTerminalTabs(myProject, myParent); |
| } |
| |
| public class JBTerminalTabs implements TerminalTabs { |
| private final JBEditorTabs myTabs; |
| |
| private TabInfo.DragOutDelegate myDragDelegate = new MyDragOutDelegate(); |
| |
| private final CopyOnWriteArraySet<TabChangeListener> myListeners = new CopyOnWriteArraySet<TabChangeListener>(); |
| |
| public JBTerminalTabs(@NotNull Project project, @NotNull Disposable parent) { |
| final ActionManager actionManager = ActionManager.getInstance(); |
| myTabs = new JBEditorTabs(project, actionManager, IdeFocusManager.getInstance(project), parent) { |
| @Override |
| protected TabLabel createTabLabel(TabInfo info) { |
| return new TerminalTabLabel(this, info); |
| } |
| }; |
| |
| myTabs.addListener(new TabsListener.Adapter() { |
| @Override |
| public void selectionChanged(TabInfo oldSelection, TabInfo newSelection) { |
| for (TabChangeListener each : myListeners) { |
| each.selectionChanged(); |
| } |
| } |
| |
| @Override |
| public void tabRemoved(TabInfo tabInfo) { |
| for (TabChangeListener each : myListeners) { |
| each.tabRemoved(); |
| } |
| } |
| }); |
| |
| myTabs.setTabDraggingEnabled(true); |
| } |
| |
| @Override |
| public int getSelectedIndex() { |
| return myTabs.getIndexOf(myTabs.getSelectedInfo()); |
| } |
| |
| @Override |
| public void setSelectedIndex(int index) { |
| myTabs.select(myTabs.getTabAt(index), true); |
| } |
| |
| @Override |
| public void setTabComponentAt(int index, Component component) { |
| //nop |
| } |
| |
| @Override |
| public int indexOfTabComponent(Component component) { |
| return 0; //nop |
| } |
| |
| |
| private TabInfo getTabAt(int index) { |
| checkIndex(index); |
| return myTabs.getTabAt(index); |
| } |
| |
| private void checkIndex(int index) { |
| if (index < 0 || index >= getTabCount()) { |
| throw new ArrayIndexOutOfBoundsException("tabCount=" + getTabCount() + " index=" + index); |
| } |
| } |
| |
| |
| @Override |
| public JediTermWidget getComponentAt(int i) { |
| return (JediTermWidget)getTabAt(i).getComponent(); |
| } |
| |
| @Override |
| public void addChangeListener(TabChangeListener listener) { |
| myListeners.add(listener); |
| } |
| |
| @Override |
| public void setTitleAt(int index, String title) { |
| getTabAt(index).setText(title); |
| } |
| |
| @Override |
| public void setSelectedComponent(JediTermWidget terminal) { |
| TabInfo info = myTabs.findInfo(terminal); |
| if (info != null) { |
| myTabs.select(info, true); |
| } |
| } |
| |
| @Override |
| public JComponent getComponent() { |
| return myTabs.getComponent(); |
| } |
| |
| @Override |
| public int getTabCount() { |
| return myTabs.getTabCount(); |
| } |
| |
| @Override |
| public void addTab(String name, JediTermWidget terminal) { |
| myTabs.addTab(createTabInfo(name, terminal)); |
| } |
| |
| private TabInfo createTabInfo(String name, JediTermWidget terminal) { |
| TabInfo tabInfo = new TabInfo(terminal).setText(name).setDragOutDelegate(myDragDelegate); |
| return tabInfo |
| .setObject(new TerminalSessionVirtualFileImpl(tabInfo, terminal, mySettingsProvider)); |
| } |
| |
| public String getTitleAt(int i) { |
| return getTabAt(i).getText(); |
| } |
| |
| public void removeAll() { |
| myTabs.removeAllTabs(); |
| } |
| |
| @Override |
| public void remove(JediTermWidget terminal) { |
| TabInfo info = myTabs.findInfo(terminal); |
| if (info != null) { |
| myTabs.removeTab(info); |
| } |
| } |
| |
| private class TerminalTabLabel extends TabLabel { |
| public TerminalTabLabel(final JBTabsImpl tabs, final TabInfo info) { |
| super(tabs, info); |
| |
| setOpaque(false); |
| |
| setFocusable(false); |
| |
| SimpleColoredComponent label = myLabel; |
| |
| //add more space between the label and the button |
| label.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5)); |
| |
| label.addMouseListener(new MouseAdapter() { |
| |
| @Override |
| public void mouseReleased(MouseEvent event) { |
| handleMouse(event); |
| } |
| |
| @Override |
| public void mousePressed(MouseEvent event) { |
| handleMouse(event); |
| } |
| |
| private void handleMouse(MouseEvent e) { |
| if (e.isPopupTrigger()) { |
| JPopupMenu menu = createPopup(); |
| menu.show(e.getComponent(), e.getX(), e.getY()); |
| } |
| else if (e.getButton() != MouseEvent.BUTTON2) { |
| myTabs.select(getInfo(), true); |
| |
| if (e.getClickCount() == 2 && !e.isConsumed()) { |
| e.consume(); |
| renameTab(); |
| } |
| } |
| } |
| |
| @Override |
| public void mouseClicked(MouseEvent e) { |
| if (e.getButton() == MouseEvent.BUTTON2) { |
| if (myTabs.getSelectedInfo() == info) { |
| closeCurrentSession(); |
| } |
| else { |
| myTabs.select(info, true); |
| } |
| } |
| } |
| }); |
| } |
| |
| protected JPopupMenu createPopup() { |
| JPopupMenu popupMenu = new JPopupMenu(); |
| |
| TerminalAction.addToMenu(popupMenu, JBTabbedTerminalWidget.this); |
| |
| JMenuItem rename = new JMenuItem("Rename Tab"); |
| |
| rename.addActionListener(new ActionListener() { |
| @Override |
| public void actionPerformed(ActionEvent actionEvent) { |
| renameTab(); |
| } |
| }); |
| |
| popupMenu.add(rename); |
| |
| return popupMenu; |
| } |
| |
| private void renameTab() { |
| new TabRenamer() { |
| @Override |
| protected JTextField createTextField() { |
| JBTextField textField = new JBTextField() { |
| private int myMinimalWidth; |
| |
| @Override |
| public Dimension getPreferredSize() { |
| Dimension size = super.getPreferredSize(); |
| if (size.width > myMinimalWidth) { |
| myMinimalWidth = size.width; |
| } |
| |
| return wider(size, myMinimalWidth); |
| } |
| |
| private Dimension wider(Dimension size, int minimalWidth) { |
| return new Dimension(minimalWidth + 10, size.height); |
| } |
| }; |
| if (myTabs.useSmallLabels()) { |
| textField.setFont(com.intellij.util.ui.UIUtil.getFont(UIUtil.FontSize.SMALL, textField.getFont())); |
| } |
| textField.setOpaque(true); |
| return textField; |
| } |
| }.install(getSelectedIndex(), getInfo().getText(), myLabel, new TabRenamer.RenameCallBack() { |
| @Override |
| public void setComponent(Component c) { |
| myTabs.setTabDraggingEnabled(!(c instanceof JBTextField)); |
| |
| setPlaceholderContent(true, (JComponent)c); |
| } |
| |
| @Override |
| public void setNewName(int index, String name) { |
| setTitleAt(index, name); |
| } |
| }); |
| } |
| } |
| |
| class MyDragOutDelegate implements TabInfo.DragOutDelegate { |
| |
| private TerminalSessionVirtualFileImpl myFile; |
| private DragSession mySession; |
| |
| @Override |
| public void dragOutStarted(MouseEvent mouseEvent, TabInfo info) { |
| final TabInfo previousSelection = info.getPreviousSelection(); |
| final Image img = JBTabsImpl.getComponentImage(info); |
| info.setHidden(true); |
| if (previousSelection != null) { |
| myTabs.select(previousSelection, true); |
| } |
| |
| myFile = (TerminalSessionVirtualFileImpl)info.getObject(); |
| Presentation presentation = new Presentation(info.getText()); |
| presentation.setIcon(info.getIcon()); |
| mySession = getDockManager() |
| .createDragSession(mouseEvent, new EditorTabbedContainer.DockableEditor(myProject, img, myFile, presentation, |
| info.getComponent().getPreferredSize(), false)); |
| } |
| |
| private DockManager getDockManager() { |
| return DockManager.getInstance(myProject); |
| } |
| |
| @Override |
| public void processDragOut(MouseEvent event, TabInfo source) { |
| mySession.process(event); |
| } |
| |
| @Override |
| public void dragOutFinished(MouseEvent event, TabInfo source) { |
| myFile.putUserData(FileEditorManagerImpl.CLOSING_TO_REOPEN, Boolean.TRUE); |
| |
| |
| myTabs.removeTab(source); |
| |
| mySession.process(event); |
| |
| myFile.putUserData(FileEditorManagerImpl.CLOSING_TO_REOPEN, null); |
| |
| |
| myFile = null; |
| mySession = null; |
| } |
| |
| @Override |
| public void dragOutCancelled(TabInfo source) { |
| source.setHidden(false); |
| if (mySession != null) { |
| mySession.cancel(); |
| } |
| |
| myFile = null; |
| mySession = null; |
| } |
| } |
| } |
| } |
