protected void addPage(String _typeOfPage, String _name, String _code, boolean _enabled) {
cardLayout.show(finalPanel, "TabbedPanel");
_name = getUniqueName(_name);
Editor page = createPage(_typeOfPage, _name, _code);
page.setFont(myFont);
page.setColor(myColor);
int index = tabbedPanel.getSelectedIndex();
if (index == -1) {
pageList.addElement(page);
if (tabbedPanel.getTabCount() == 0) {
tabbedPanel.addTab(
page.getName(),
null,
page.getComponent(),
tooltip); // This causes an exception sometimes
} else {
tabbedPanel.insertTab(
page.getName(), null, page.getComponent(), tooltip, tabbedPanel.getTabCount());
}
index = 0;
} else {
index++;
pageList.insertElementAt(page, index);
tabbedPanel.insertTab(page.getName(), null, page.getComponent(), tooltip, index);
}
tabbedPanel.setSelectedComponent(page.getComponent());
page.setActive(_enabled);
if (!_enabled) tabbedPanel.setTitleAt(index, page.getName() + " (D)");
updatePageCounterField(pageList.size());
// tabbedPanel.validate(); This hangs the computer when reading a file at start-up !!!???
tabbedPanel.repaint();
changed = true;
}
private void moveUpAndDownPage(boolean _up) {
int index = tabbedPanel.getSelectedIndex();
if (index < 0) return;
Editor page = pageList.get(index);
if (page == null) return;
if (_up) {
if (index == 0) return;
pageList.removeElementAt(index);
pageList.insertElementAt(page, index - 1);
tabbedPanel.removeTabAt(index);
tabbedPanel.insertTab(
page.isActive() ? page.getName() : page.getName() + " (D)",
null,
page.getComponent(),
tooltip,
index - 1);
} else {
if (index == (pageList.size() - 1)) return;
pageList.removeElementAt(index);
pageList.insertElementAt(page, index + 1);
tabbedPanel.removeTabAt(index);
tabbedPanel.insertTab(
page.isActive() ? page.getName() : page.getName() + " (D)",
null,
page.getComponent(),
tooltip,
index + 1);
}
tabbedPanel.setSelectedComponent(page.getComponent());
changed = true;
}
public void showPage(Editor anEditor) {
for (int i = 0, n = tabbedPanel.getComponentCount(); i < n; i++) {
if (tabbedPanel.getComponent(i) == anEditor.getComponent()) {
// System.out.println ("Found editor "+anEditor.getName()+ " at i="+i);
ejs.showPanel(defaultHeader);
cardLayout.show(finalPanel, anEditor.getName());
tabbedPanel.setSelectedComponent(anEditor.getComponent());
return;
}
}
}
/**
* Emulates pressing <code>Enter</code> at current caret position.
*
* @param editor target editor
* @param project target project
* @param shifts two-elements array which is expected to be filled with the following info: 1. The
* first element holds added lines number; 2. The second element holds added symbols number;
*/
private static void emulateEnter(
@NotNull final Editor editor, @NotNull Project project, int[] shifts) {
final DataContext dataContext = prepareContext(editor.getComponent(), project);
int caretOffset = editor.getCaretModel().getOffset();
Document document = editor.getDocument();
SelectionModel selectionModel = editor.getSelectionModel();
int startSelectionOffset = 0;
int endSelectionOffset = 0;
boolean restoreSelection = selectionModel.hasSelection();
if (restoreSelection) {
startSelectionOffset = selectionModel.getSelectionStart();
endSelectionOffset = selectionModel.getSelectionEnd();
selectionModel.removeSelection();
}
int textLengthBeforeWrap = document.getTextLength();
int lineCountBeforeWrap = document.getLineCount();
DataManager.getInstance()
.saveInDataContext(dataContext, WRAP_LONG_LINE_DURING_FORMATTING_IN_PROGRESS_KEY, true);
CommandProcessor commandProcessor = CommandProcessor.getInstance();
try {
Runnable command =
new Runnable() {
@Override
public void run() {
EditorActionManager.getInstance()
.getActionHandler(IdeActions.ACTION_EDITOR_ENTER)
.execute(editor, dataContext);
}
};
if (commandProcessor.getCurrentCommand() == null) {
commandProcessor.executeCommand(editor.getProject(), command, WRAP_LINE_COMMAND_NAME, null);
} else {
command.run();
}
} finally {
DataManager.getInstance()
.saveInDataContext(dataContext, WRAP_LONG_LINE_DURING_FORMATTING_IN_PROGRESS_KEY, null);
}
int symbolsDiff = document.getTextLength() - textLengthBeforeWrap;
if (restoreSelection) {
int newSelectionStart = startSelectionOffset;
int newSelectionEnd = endSelectionOffset;
if (startSelectionOffset >= caretOffset) {
newSelectionStart += symbolsDiff;
}
if (endSelectionOffset >= caretOffset) {
newSelectionEnd += symbolsDiff;
}
selectionModel.setSelection(newSelectionStart, newSelectionEnd);
}
shifts[0] = document.getLineCount() - lineCountBeforeWrap;
shifts[1] = symbolsDiff;
}
public ImplementationViewComponent(PsiElement[] elements, final int index) {
super(new BorderLayout());
final Project project = elements.length > 0 ? elements[0].getProject() : null;
EditorFactory factory = EditorFactory.getInstance();
Document doc = factory.createDocument("");
doc.setReadOnly(true);
myEditor = factory.createEditor(doc, project);
((EditorEx) myEditor).setBackgroundColor(EditorFragmentComponent.getBackgroundColor(myEditor));
final EditorSettings settings = myEditor.getSettings();
settings.setAdditionalLinesCount(1);
settings.setAdditionalColumnsCount(1);
settings.setLineMarkerAreaShown(false);
settings.setIndentGuidesShown(false);
settings.setLineNumbersShown(false);
settings.setFoldingOutlineShown(false);
myBinarySwitch = new CardLayout();
myViewingPanel = new JPanel(myBinarySwitch);
myEditor.setBorder(null);
((EditorEx) myEditor).getScrollPane().setViewportBorder(JBScrollPane.createIndentBorder());
myViewingPanel.add(myEditor.getComponent(), TEXT_PAGE_KEY);
myBinaryPanel = new JPanel(new BorderLayout());
myViewingPanel.add(myBinaryPanel, BINARY_PAGE_KEY);
add(myViewingPanel, BorderLayout.CENTER);
myToolbar = createToolbar();
myLocationLabel = new JLabel();
myCountLabel = new JLabel();
final JPanel header = new JPanel(new BorderLayout(2, 0));
header.setBorder(
BorderFactory.createCompoundBorder(
IdeBorderFactory.createBorder(SideBorder.BOTTOM),
IdeBorderFactory.createEmptyBorder(0, 0, 0, 5)));
final JPanel toolbarPanel = new JPanel(new GridBagLayout());
final GridBagConstraints gc =
new GridBagConstraints(
GridBagConstraints.RELATIVE,
0,
1,
1,
0,
0,
GridBagConstraints.WEST,
GridBagConstraints.NONE,
new Insets(0, 2, 0, 0),
0,
0);
toolbarPanel.add(myToolbar.getComponent(), gc);
setPreferredSize(new Dimension(600, 400));
update(
elements,
new PairFunction<PsiElement[], List<FileDescriptor>, Boolean>() {
@Override
public Boolean fun(
final PsiElement[] psiElements, final List<FileDescriptor> fileDescriptors) {
if (psiElements.length == 0) return false;
myElements = psiElements;
myIndex = index < myElements.length ? index : 0;
PsiFile psiFile = getContainingFile(myElements[myIndex]);
VirtualFile virtualFile = psiFile.getVirtualFile();
EditorHighlighter highlighter;
if (virtualFile != null)
highlighter = HighlighterFactory.createHighlighter(project, virtualFile);
else {
String fileName = psiFile.getName(); // some artificial psi file, lets do best we can
highlighter = HighlighterFactory.createHighlighter(project, fileName);
}
((EditorEx) myEditor).setHighlighter(highlighter);
gc.fill = GridBagConstraints.HORIZONTAL;
gc.weightx = 1;
if (myElements.length > 1) {
myFileChooser =
new ComboBox(
fileDescriptors.toArray(new FileDescriptor[fileDescriptors.size()]), 250);
updateRenderer(project);
myFileChooser.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int index = myFileChooser.getSelectedIndex();
if (myIndex != index) {
myIndex = index;
updateControls();
}
}
});
myLabel = new JLabel();
myLabel.setVisible(false);
toolbarPanel.add(myFileChooser, gc);
} else {
myFileChooser = new ComboBox();
myFileChooser.setVisible(false);
myCountLabel.setVisible(false);
myLabel = new JLabel();
VirtualFile file = psiFile.getVirtualFile();
if (file != null) {
myLabel.setIcon(getIconForFile(psiFile));
myLabel.setForeground(
FileStatusManager.getInstance(project).getStatus(file).getColor());
myLabel.setText(file.getPresentableName());
myLabel.setBorder(
new CompoundBorder(
IdeBorderFactory.createRoundedBorder(),
IdeBorderFactory.createEmptyBorder(0, 0, 0, 5)));
}
toolbarPanel.add(myLabel, gc);
}
gc.fill = GridBagConstraints.NONE;
gc.weightx = 0;
toolbarPanel.add(myCountLabel, gc);
header.add(toolbarPanel, BorderLayout.CENTER);
header.add(myLocationLabel, BorderLayout.EAST);
add(header, BorderLayout.NORTH);
updateControls();
return true;
}
});
}
private void recreateEditorsPanel() {
myValuesPanel.removeAll();
myValuesPanel.setLayout(new CardLayout());
if (!myProject.isOpen()) return;
JPanel valuesPanelComponent = new MyJPanel(new GridBagLayout());
myValuesPanel.add(
new JBScrollPane(valuesPanelComponent) {
@Override
public void updateUI() {
super.updateUI();
getViewport().setBackground(UIUtil.getPanelBackground());
}
},
VALUES);
myValuesPanel.add(myNoPropertySelectedPanel, NO_PROPERTY_SELECTED);
List<PropertiesFile> propertiesFiles = myResourceBundle.getPropertiesFiles();
GridBagConstraints gc =
new GridBagConstraints(
0,
0,
0,
0,
0,
0,
GridBagConstraints.NORTHWEST,
GridBagConstraints.BOTH,
new Insets(5, 5, 5, 5),
0,
0);
releaseAllEditors();
myTitledPanels.clear();
int y = 0;
Editor previousEditor = null;
Editor firstEditor = null;
for (final PropertiesFile propertiesFile : propertiesFiles) {
final Editor editor = createEditor();
final Editor oldEditor = myEditors.put(propertiesFile, editor);
if (firstEditor == null) {
firstEditor = editor;
}
if (previousEditor != null) {
editor.putUserData(
ChooseSubsequentPropertyValueEditorAction.PREV_EDITOR_KEY, previousEditor);
previousEditor.putUserData(
ChooseSubsequentPropertyValueEditorAction.NEXT_EDITOR_KEY, editor);
}
previousEditor = editor;
if (oldEditor != null) {
EditorFactory.getInstance().releaseEditor(oldEditor);
}
((EditorEx) editor)
.addFocusListener(
new FocusChangeListener() {
@Override
public void focusGained(final Editor editor) {
mySelectedEditor = editor;
}
@Override
public void focusLost(final Editor eventEditor) {
writeEditorPropertyValue(editor, propertiesFile, null);
}
});
gc.gridx = 0;
gc.gridy = y++;
gc.gridheight = 1;
gc.gridwidth = GridBagConstraints.REMAINDER;
gc.weightx = 1;
gc.weighty = 1;
gc.anchor = GridBagConstraints.CENTER;
Locale locale = propertiesFile.getLocale();
List<String> names = new ArrayList<String>();
if (!Comparing.strEqual(locale.getDisplayLanguage(), null)) {
names.add(locale.getDisplayLanguage());
}
if (!Comparing.strEqual(locale.getDisplayCountry(), null)) {
names.add(locale.getDisplayCountry());
}
if (!Comparing.strEqual(locale.getDisplayVariant(), null)) {
names.add(locale.getDisplayVariant());
}
String title = propertiesFile.getName();
if (!names.isEmpty()) {
title += " (" + StringUtil.join(names, "/") + ")";
}
JComponent comp =
new JPanel(new BorderLayout()) {
@Override
public Dimension getPreferredSize() {
Insets insets = getBorder().getBorderInsets(this);
return new Dimension(100, editor.getLineHeight() * 4 + insets.top + insets.bottom);
}
};
comp.add(editor.getComponent(), BorderLayout.CENTER);
comp.setBorder(IdeBorderFactory.createTitledBorder(title, true));
myTitledPanels.put(propertiesFile, (JPanel) comp);
valuesPanelComponent.add(comp, gc);
}
if (previousEditor != null) {
previousEditor.putUserData(
ChooseSubsequentPropertyValueEditorAction.NEXT_EDITOR_KEY, firstEditor);
firstEditor.putUserData(
ChooseSubsequentPropertyValueEditorAction.PREV_EDITOR_KEY, previousEditor);
}
gc.gridx = 0;
gc.gridy = y;
gc.gridheight = GridBagConstraints.REMAINDER;
gc.gridwidth = GridBagConstraints.REMAINDER;
gc.weightx = 10;
gc.weighty = 1;
valuesPanelComponent.add(new JPanel(), gc);
selectionChanged();
myValuesPanel.repaint();
UIUtil.invokeAndWaitIfNeeded(
new Runnable() {
@Override
public void run() {
updateEditorsFromProperties();
}
});
}
private static void doPaste(
final Editor editor,
final Project project,
final PsiFile file,
final Document document,
final Producer<Transferable> producer) {
Transferable content = null;
if (producer != null) {
content = producer.produce();
} else {
CopyPasteManager manager = CopyPasteManager.getInstance();
if (manager.areDataFlavorsAvailable(DataFlavor.stringFlavor)) {
content = manager.getContents();
if (content != null) {
manager.stopKillRings();
}
}
}
if (content != null) {
String text = null;
try {
text = (String) content.getTransferData(DataFlavor.stringFlavor);
} catch (Exception e) {
editor.getComponent().getToolkit().beep();
}
if (text == null) return;
final CodeInsightSettings settings = CodeInsightSettings.getInstance();
final Map<CopyPastePostProcessor, TextBlockTransferableData> extraData =
new HashMap<CopyPastePostProcessor, TextBlockTransferableData>();
for (CopyPastePostProcessor processor :
Extensions.getExtensions(CopyPastePostProcessor.EP_NAME)) {
TextBlockTransferableData data = processor.extractTransferableData(content);
if (data != null) {
extraData.put(processor, data);
}
}
text = TextBlockTransferable.convertLineSeparators(text, "\n", extraData.values());
final CaretModel caretModel = editor.getCaretModel();
final SelectionModel selectionModel = editor.getSelectionModel();
final int col = caretModel.getLogicalPosition().column;
// There is a possible case that we want to perform paste while there is an active selection
// at the editor and caret is located
// inside it (e.g. Ctrl+A is pressed while caret is not at the zero column). We want to insert
// the text at selection start column
// then, hence, inserted block of text should be indented according to the selection start as
// well.
final int blockIndentAnchorColumn;
final int caretOffset = caretModel.getOffset();
if (selectionModel.hasSelection() && caretOffset >= selectionModel.getSelectionStart()) {
blockIndentAnchorColumn =
editor.offsetToLogicalPosition(selectionModel.getSelectionStart()).column;
} else {
blockIndentAnchorColumn = col;
}
// We assume that EditorModificationUtil.insertStringAtCaret() is smart enough to remove
// currently selected text (if any).
RawText rawText = RawText.fromTransferable(content);
String newText = text;
for (CopyPastePreProcessor preProcessor :
Extensions.getExtensions(CopyPastePreProcessor.EP_NAME)) {
newText = preProcessor.preprocessOnPaste(project, file, editor, newText, rawText);
}
int indentOptions =
text.equals(newText) ? settings.REFORMAT_ON_PASTE : CodeInsightSettings.REFORMAT_BLOCK;
text = newText;
if (LanguageFormatting.INSTANCE.forContext(file) == null
&& indentOptions != CodeInsightSettings.NO_REFORMAT) {
indentOptions = CodeInsightSettings.INDENT_BLOCK;
}
final String _text = text;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
EditorModificationUtil.insertStringAtCaret(editor, _text, false, true);
}
});
int length = text.length();
int offset = caretModel.getOffset() - length;
if (offset < 0) {
length += offset;
offset = 0;
}
final RangeMarker bounds = document.createRangeMarker(offset, offset + length);
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
final Ref<Boolean> indented = new Ref<Boolean>(Boolean.FALSE);
for (Map.Entry<CopyPastePostProcessor, TextBlockTransferableData> e : extraData.entrySet()) {
//noinspection unchecked
e.getKey()
.processTransferableData(project, editor, bounds, caretOffset, indented, e.getValue());
}
boolean pastedTextContainsWhiteSpacesOnly =
CharArrayUtil.shiftForward(document.getCharsSequence(), bounds.getStartOffset(), " \n\t")
>= bounds.getEndOffset();
VirtualFile virtualFile = file.getVirtualFile();
if (!pastedTextContainsWhiteSpacesOnly
&& (virtualFile == null
|| !SingleRootFileViewProvider.isTooLargeForIntelligence(virtualFile))) {
final int indentOptions1 = indentOptions;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
switch (indentOptions1) {
case CodeInsightSettings.INDENT_BLOCK:
if (!indented.get()) {
indentBlock(
project,
editor,
bounds.getStartOffset(),
bounds.getEndOffset(),
blockIndentAnchorColumn);
}
break;
case CodeInsightSettings.INDENT_EACH_LINE:
if (!indented.get()) {
indentEachLine(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
}
break;
case CodeInsightSettings.REFORMAT_BLOCK:
indentEachLine(
project,
editor,
bounds.getStartOffset(),
bounds
.getEndOffset()); // this is needed for example when inserting a
// comment before method
reformatBlock(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
break;
}
}
});
}
if (bounds.isValid()) {
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
editor.putUserData(EditorEx.LAST_PASTED_REGION, TextRange.create(bounds));
}
}
}