@Override
public void focusGained(final FocusEvent e) {
final JTextComponent component = getComponent();
if (!component.isEnabled() || !component.isEditable()) {
super.focusGained(e);
return;
}
mFocused = true;
if (!shouldSelectAllOnFocus) {
shouldSelectAllOnFocus = true;
super.focusGained(e);
return;
}
if (isMultiLineEditor) {
super.focusGained(e);
return;
}
final int end = component.getDocument().getLength();
final int dot = getDot();
final int mark = getMark();
if (dot == mark) {
if (dot == 0) {
component.setCaretPosition(end);
component.moveCaretPosition(0);
} else if (dot == end) {
component.setCaretPosition(0);
component.moveCaretPosition(end);
}
}
super.focusGained(e);
}
// public static final String showElementTreeAction = "showElementTree";
// -------------------------------------------------------------
public void openFile(String currDirStr, String currFileStr) {
if (fileDialog == null) {
fileDialog = new FileDialog(this);
}
fileDialog.setMode(FileDialog.LOAD);
if (!(currDirStr.equals(""))) {
fileDialog.setDirectory(currDirStr);
}
if (!(currFileStr.equals(""))) {
fileDialog.setFile(currFileStr);
}
fileDialog.show();
String file = fileDialog.getFile(); // cancel pushed
if (file == null) {
return;
}
String directory = fileDialog.getDirectory();
File f = new File(directory, file);
if (f.exists()) {
Document oldDoc = getEditor().getDocument();
if (oldDoc != null)
// oldDoc.removeUndoableEditListener(undoHandler);
/*
if (elementTreePanel != null) {
elementTreePanel.setEditor(null);
}
*/
getEditor().setDocument(new PlainDocument());
fileDialog.setTitle(file);
Thread loader = new FileLoader(f, editor1.getDocument());
loader.start();
}
}
/*
* We need to know if the caret is currently positioned on the line we
* are about to paint so the line number can be highlighted.
*/
private boolean isCurrentLine(int rowStartOffset) {
int caretPosition = component.getCaretPosition();
Element root = component.getDocument().getDefaultRootElement();
if (root.getElementIndex(rowStartOffset) == root.getElementIndex(caretPosition)) return true;
else return false;
}
/*
* Get the line number to be drawn. The empty string will be returned
* when a line of text has wrapped.
*/
protected String getTextLineNumber(int rowStartOffset) {
Element root = component.getDocument().getDefaultRootElement();
int index = root.getElementIndex(rowStartOffset);
Element line = root.getElement(index);
if (line.getStartOffset() == rowStartOffset) return String.valueOf(index + 1);
else return "";
}
void removeText() {
if ((p0 != null) && (p1 != null) && (p0.getOffset() != p1.getOffset())) {
try {
Document doc = c.getDocument();
doc.remove(p0.getOffset(), p1.getOffset() - p0.getOffset());
} catch (BadLocationException e) {
}
}
}
TextTransferable(JTextComponent c, int start, int end) {
this.c = c;
Document doc = c.getDocument();
try {
p0 = doc.createPosition(start);
p1 = doc.createPosition(end);
plainData = c.getSelectedText();
} catch (BadLocationException ble) {
}
}
private void outdentText(JTextComponent textComponent) throws BadLocationException {
int tabSize =
((Integer) textComponent.getDocument().getProperty(PlainDocument.tabSizeAttribute))
.intValue();
String selectedText = textComponent.getSelectedText();
int newLineIndex = selectedText != null ? selectedText.indexOf('\n') : -1;
if (newLineIndex >= 0) {
int originalSelectionStart = textComponent.getSelectionStart();
int selectionStart = originalSelectionStart;
int selectionEnd = textComponent.getSelectionEnd();
int lastNewLineBeforeSelection = textComponent.getText(0, selectionStart).lastIndexOf('\n');
int begin = lastNewLineBeforeSelection >= 0 ? lastNewLineBeforeSelection : 0;
int end = selectionEnd;
String text = textComponent.getText(begin, end - begin);
if (lastNewLineBeforeSelection < 0) {
text = "\n" + text;
}
int len = text.length();
StringBuffer out = new StringBuffer(len);
for (int i = 0; i < len; i++) {
char ch = text.charAt(i);
out.append(ch);
if (ch == '\n' && i < len - 1) {
char next = text.charAt(i + 1);
int stripCount = 0;
if (next == '\t') {
stripCount = 1;
} else {
for (; stripCount < tabSize && i + 1 + stripCount < len; stripCount++) {
next = text.charAt(i + 1 + stripCount);
if (next != ' ' && next != '\t') {
break;
}
}
}
selectionEnd -= stripCount;
if (i + begin < originalSelectionStart - 1) {
selectionStart -= stripCount;
}
i += stripCount;
}
}
textComponent.select(begin, end);
textComponent.replaceSelection(
lastNewLineBeforeSelection < 0 ? out.toString().substring(1) : out.toString());
textComponent.select(selectionStart, selectionEnd);
}
}
/**
* @param baseURL may be <code>null</code>
* @see PropertyPanel.PropertyField#setText
*/
void setText(String text, String baseURL, DocumentListener documentListener) {
//
textComponent.getDocument().removeDocumentListener(documentListener);
//
if (editorType == EDITOR_TYPE_STYLED) {
//
// --- set content type ---
((JEditorPane) textComponent).setContentType("text/html");
//
// --- set base URL ---
try {
// Note: baseURL is null if no baseURL is set for the corresponding property
// Note: baseURL is empty if corporate baseURL is used but not set
if (baseURL != null && !baseURL.equals("")) {
((HTMLDocument) textComponent.getDocument()).setBase(new URL(baseURL));
}
} catch (MalformedURLException mue) {
System.out.println("*** TextEditorPanel.setText(): invalid base URL: " + mue);
}
//
// --- set text ---
try {
if (text.length() <= 59) { // ### 59 <html><head></head><body></body></html> + whitespace
text = "<html><body><p></p></body></html>";
}
textComponent.setText(text);
textComponent.setCaretPosition(0);
} catch (Throwable e) {
textComponent.setText(
"<html><body><font color=#FF0000>Page can't be displayed</font></body></html>");
System.out.println("*** TextEditorPanel.setText(): error while HTML rendering: " + e);
}
} else {
textComponent.setText(text);
textComponent.setCaretPosition(0);
}
//
textComponent.getDocument().addDocumentListener(documentListener);
}
/**
* Create a line number component for a text component.
*
* @param argComponent the related text component
* @param argMinimumDisplayDigits the number of digits used to calculate the minimum width of the
* component.
*/
public TextLineNumber(JTextComponent argComponent, int argMinimumDisplayDigits) {
component = argComponent;
setFont(argComponent.getFont());
setBorderGap(5);
setCurrentLineForeground(Color.RED);
setDigitAlignment(RIGHT);
setMinimumDisplayDigits(argMinimumDisplayDigits);
argComponent.getDocument().addDocumentListener(this);
argComponent.addCaretListener(this);
argComponent.addPropertyChangeListener("font", this);
}
//
// Implement CaretListener interface
//
@Override
public void caretUpdate(CaretEvent e) {
// Get the line the caret is positioned on
int caretPosition = component.getCaretPosition();
Element root = component.getDocument().getDefaultRootElement();
int currentLine = root.getElementIndex(caretPosition);
// Need to repaint so the correct line number can be highlighted
if (lastLine != currentLine) {
repaint();
lastLine = currentLine;
}
}
/*
* Determine the Y offset for the current row
*/
private int getOffsetY(int rowStartOffset, FontMetrics fontMetrics) throws BadLocationException {
// Get the bounding rectangle of the row
Rectangle r = component.modelToView(rowStartOffset);
int lineHeight = fontMetrics.getHeight();
int y = r.y + r.height;
int descent = 0;
// The text needs to be positioned above the bottom of the bounding
// rectangle based on the descent of the font(s) contained on the row.
if (r.height == lineHeight) {
// default font is being used
descent = fontMetrics.getDescent();
} else {
// We need to check all the attributes for font changes
if (fonts == null) {
fonts = new HashMap<String, FontMetrics>();
}
Element root = component.getDocument().getDefaultRootElement();
int index = root.getElementIndex(rowStartOffset);
Element line = root.getElement(index);
for (int i = 0; i < line.getElementCount(); i++) {
Element child = line.getElement(i);
AttributeSet as = child.getAttributes();
String fontFamily = (String) as.getAttribute(StyleConstants.FontFamily);
Integer fontSize = (Integer) as.getAttribute(StyleConstants.FontSize);
String key = fontFamily + fontSize;
FontMetrics fm = fonts.get(key);
if (fm == null) {
Font font = new Font(fontFamily, Font.PLAIN, fontSize);
fm = component.getFontMetrics(font);
fonts.put(key, fm);
}
descent = Math.max(descent, fm.getDescent());
}
}
return y - descent;
}
/** Calculate the width needed to display the maximum line number */
private void setPreferredWidth() {
Element root = component.getDocument().getDefaultRootElement();
int lines = root.getElementCount();
int digits = Math.max(String.valueOf(lines).length(), minimumDisplayDigits);
// Update sizes when number of digits in the line number changes
if (lastDigits != digits) {
lastDigits = digits;
FontMetrics fontMetrics = getFontMetrics(getFont());
int width = fontMetrics.charWidth('0') * digits;
Insets insets = getInsets();
int preferredWidth = insets.left + insets.right + width;
Dimension d = getPreferredSize();
d.setSize(preferredWidth, HEIGHT);
setPreferredSize(d);
setSize(d);
}
}
/*
* A document change may affect the number of displayed lines of text.
* Therefore the lines numbers will also change.
*/
private void documentChanged() {
// View of the component has not been updated at the time
// the DocumentEvent is fired
SwingUtilities.invokeLater(
() -> {
try {
int endPos = component.getDocument().getLength();
Rectangle rect = component.modelToView(endPos);
if (rect != null && rect.y != lastHeight) {
setPreferredWidth();
repaint();
lastHeight = rect.y;
}
} catch (BadLocationException ex) {
/* nothing to do */
}
});
}
public void actionPerformed(JTextComponent text) {
indentationLogic = ((EditorPane) text).getIndentationLogic();
StyledDocument doc = (StyledDocument) text.getDocument();
Element map = doc.getDefaultRootElement();
Caret c = text.getCaret();
int dot = c.getDot();
int mark = c.getMark();
int line1 = map.getElementIndex(dot);
if (dot != mark) {
int line2 = map.getElementIndex(mark);
int begin = Math.min(line1, line2);
int end = Math.max(line1, line2);
Element elem;
try {
for (line1 = begin; line1 < end; line1++) {
elem = map.getElement(line1);
handleDecreaseIndent(line1, elem, doc);
}
elem = map.getElement(end);
int start = elem.getStartOffset();
if (Math.max(c.getDot(), c.getMark()) != start) {
handleDecreaseIndent(end, elem, doc);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
} else {
Element elem = map.getElement(line1);
try {
handleDecreaseIndent(line1, elem, doc);
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
}
}
// Create a Transferable implementation that contains the selected text.
protected Transferable createTransferable(JComponent c) {
if (c != textComponent) { // ###
System.out.println("*** createTransferable(): c=" + c);
}
source = (JTextComponent) c;
int start = source.getSelectionStart();
int end = source.getSelectionEnd();
Document doc = source.getDocument();
if (start == end) {
return null;
}
try {
p0 = doc.createPosition(start);
p1 = doc.createPosition(end);
System.out.println(">>> createTransferable(): p0=" + p0 + ", p1=" + p1);
} catch (BadLocationException e) {
System.out.println(
"*** createTransferable(): "
+ "Can't create position - unable to remove text from source.");
}
shouldRemove = true;
String data = source.getSelectedText();
return new StringSelection(data);
}
public void actionPerformed(JTextComponent text) {
indentationLogic = ((EditorPane) text).getIndentationLogic();
boolean indentError = false;
Document doc = text.getDocument();
Element map = doc.getDefaultRootElement();
String tabWhitespace = PreferencesUser.getInstance().getTabWhitespace();
Caret c = text.getCaret();
int dot = c.getDot();
int mark = c.getMark();
int dotLine = map.getElementIndex(dot);
int markLine = map.getElementIndex(mark);
if (dotLine != markLine) {
int first = Math.min(dotLine, markLine);
int last = Math.max(dotLine, markLine);
Element elem;
int start;
try {
for (int i = first; i < last; i++) {
elem = map.getElement(i);
start = elem.getStartOffset();
doc.insertString(start, tabWhitespace, null);
}
elem = map.getElement(last);
start = elem.getStartOffset();
if (Math.max(c.getDot(), c.getMark()) != start) {
doc.insertString(start, tabWhitespace, null);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
} else {
text.replaceSelection(tabWhitespace);
}
}
private void insertNewlineWithAutoIndent(JTextComponent text) {
try {
int caretPos = text.getCaretPosition();
StyledDocument doc = (StyledDocument) text.getDocument();
Element map = doc.getDefaultRootElement();
int lineNum = map.getElementIndex(caretPos);
Element line = map.getElement(lineNum);
int start = line.getStartOffset();
int end = line.getEndOffset() - 1;
int len = end - start;
String s = doc.getText(start, len);
String leadingWS = PythonIndentation.getLeadingWhitespace(doc, start, caretPos - start);
StringBuffer sb = new StringBuffer("\n");
sb.append(leadingWS);
// TODO better control over automatic indentation
indentationLogic.checkIndent(leadingWS, lineNum + 1);
// If there is only whitespace between the caret and
// the EOL, pressing Enter auto-indents the new line to
// the same place as the previous line.
int nonWhitespacePos = PythonIndentation.atEndOfLine(doc, caretPos, start, s, len);
if (nonWhitespacePos == -1) {
if (leadingWS.length() == len) {
// If the line was nothing but whitespace, select it
// so its contents get removed.
text.setSelectionStart(start);
} else {
// Select the whitespace between the caret and the EOL
// to remove it
text.setSelectionStart(caretPos);
}
text.setSelectionEnd(end);
text.replaceSelection(sb.toString());
// auto-indentation for python statements like if, while, for, try,
// except, def, class and auto-deindentation for break, continue,
// pass, return
analyseDocument(doc, lineNum, indentationLogic);
// auto-completion: add colon if it is obvious
if (indentationLogic.shouldAddColon()) {
doc.insertString(caretPos, ":", null);
indentationLogic.setLastLineEndsWithColon();
}
int lastLineChange = indentationLogic.shouldChangeLastLineIndentation();
int nextLineChange = indentationLogic.shouldChangeNextLineIndentation();
if (lastLineChange != 0) {
Debug.log(5, "change line %d indentation by %d columns", lineNum + 1, lastLineChange);
changeIndentation((DefaultStyledDocument) doc, lineNum, lastLineChange);
// nextLineChange was determined based on indentation of last line before
// the change
nextLineChange += lastLineChange;
}
if (nextLineChange != 0) {
Debug.log(5, "change line %d indentation by %d columns", lineNum + 2, nextLineChange);
changeIndentation((DefaultStyledDocument) doc, lineNum + 1, nextLineChange);
}
} // If there is non-whitespace between the caret and the
// EOL, pressing Enter takes that text to the next line
// and auto-indents it to the same place as the last
// line. Additional auto-indentation or dedentation for
// specific python statements is only done for the next line.
else {
text.setCaretPosition(nonWhitespacePos);
doc.insertString(nonWhitespacePos, sb.toString(), null);
analyseDocument(doc, lineNum, indentationLogic);
int nextLineChange = indentationLogic.shouldChangeNextLineIndentation();
if (nextLineChange != 0) {
Debug.log(5, "change line %d indentation by %d columns", lineNum + 2, nextLineChange);
changeIndentation((DefaultStyledDocument) doc, lineNum + 1, nextLineChange);
}
}
} catch (BadLocationException ble) {
text.replaceSelection("\n");
Debug.error(me + "Problem while inserting new line with auto-indent\n%s", ble.getMessage());
}
}