@Override
protected Transferable createTransferable(JComponent c) {
JTextPane aTextPane = (JTextPane) c;
HTMLEditorKit kit = ((HTMLEditorKit) aTextPane.getEditorKit());
StyledDocument sdoc = aTextPane.getStyledDocument();
int sel_start = aTextPane.getSelectionStart();
int sel_end = aTextPane.getSelectionEnd();
int i = sel_start;
StringBuilder output = new StringBuilder();
while (i < sel_end) {
Element e = sdoc.getCharacterElement(i);
Object nameAttr = e.getAttributes().getAttribute(StyleConstants.NameAttribute);
int start = e.getStartOffset(), end = e.getEndOffset();
if (nameAttr == HTML.Tag.BR) {
output.append("\n");
} else if (nameAttr == HTML.Tag.CONTENT) {
if (start < sel_start) {
start = sel_start;
}
if (end > sel_end) {
end = sel_end;
}
try {
String str = sdoc.getText(start, end - start);
output.append(str);
} catch (BadLocationException ble) {
Debug.error(me + "Copy-paste problem!\n%s", ble.getMessage());
}
}
i = end;
}
return new StringSelection(output.toString());
}
// TODO: make this a method of SikuliDocument, no need to pass document as argument
private void changeIndentation(DefaultStyledDocument doc, int linenum, int columns)
throws BadLocationException {
PreferencesUser pref = PreferencesUser.getInstance();
boolean expandTab = pref.getExpandTab();
int tabWidth = pref.getTabWidth();
if (linenum < 0) {
throw new BadLocationException("Negative line", -1);
}
Element map = doc.getDefaultRootElement();
if (linenum >= map.getElementCount()) {
throw new BadLocationException("No such line", doc.getLength() + 1);
}
if (columns == 0) {
return;
}
Element lineElem = map.getElement(linenum);
int lineStart = lineElem.getStartOffset();
int lineLength = lineElem.getEndOffset() - lineStart;
String line = doc.getText(lineStart, lineLength);
// determine current indentation and number of whitespace characters
int wsChars;
int indentation = 0;
for (wsChars = 0; wsChars < line.length(); wsChars++) {
char c = line.charAt(wsChars);
if (c == ' ') {
indentation++;
} else if (c == '\t') {
indentation += tabWidth;
} else {
break;
}
}
int newIndentation = indentation + columns;
if (newIndentation <= 0) {
doc.remove(lineStart, wsChars);
return;
}
// build whitespace string for new indentation
StringBuilder newWs = new StringBuilder(newIndentation / tabWidth + tabWidth - 1);
int ind = 0;
if (!expandTab) {
for (; ind + tabWidth <= newIndentation; ind += tabWidth) {
newWs.append('\t');
}
}
for (; ind < newIndentation; ind++) {
newWs.append(' ');
}
doc.replace(lineStart, wsChars, newWs.toString(), null);
}
public int computeDocumentOffset(int line, int column) throws BadLocationException {
if (line < 0 || column < 0) throw new BadLocationException("Negative line/col", -1);
Element lineElement = editor.getDocument().getDefaultRootElement().getElement(line - 1);
int beginLineOffset = lineElement.getStartOffset();
int endLineOffset = lineElement.getEndOffset();
String text = editor.getDocument().getText(beginLineOffset, endLineOffset - beginLineOffset);
int parserChar = 1;
int documentChar = 0;
while (parserChar < column) {
if (documentChar < text.length() && text.charAt(documentChar) == '\t') {
parserChar += 8;
documentChar += 1;
} else {
parserChar += 1;
documentChar += 1;
}
}
return beginLineOffset + documentChar;
}
/** Returns the offset where the selection ends on the specified line. */
public int getSelectionEnd(int line) {
if (line == selectionEndLine) return selectionEnd;
else if (rectSelect) {
Element map = document.getDefaultRootElement();
int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();
Element lineElement = map.getElement(line);
int lineStart = lineElement.getStartOffset();
int lineEnd = lineElement.getEndOffset() - 1;
return Math.min(lineEnd, lineStart + end);
} else return getLineEndOffset(line) - 1;
}
private void handleDecreaseIndent(int line, Element elem, StyledDocument doc)
throws BadLocationException {
int start = elem.getStartOffset();
int end = elem.getEndOffset() - 1;
doc.getText(start, end - start, segLine);
int i = segLine.offset;
end = i + segLine.count;
if (end > i) {
String leadingWS = PythonIndentation.getLeadingWhitespace(doc, start, end - start);
int toRemove = indentationLogic.checkDedent(leadingWS, line + 1);
doc.remove(start, toRemove);
}
}
public File reparseBefore() {
Element e = this.getDocument().getDefaultRootElement();
if (e.getEndOffset() - e.getStartOffset() == 1) {
return null;
}
File temp = FileManager.createTempFile("reparse");
try {
writeFile(temp.getAbsolutePath());
return temp;
} catch (IOException ex) {
}
return null;
}
// <editor-fold defaultstate="collapsed" desc="replace text patterns with image buttons">
public boolean reparse() {
File temp = null;
Element e = this.getDocument().getDefaultRootElement();
if (e.getEndOffset() - e.getStartOffset() == 1) {
return true;
}
if ((temp = reparseBefore()) != null) {
if (reparseAfter(temp)) {
updateDocumentListeners();
return true;
}
}
return false;
}
private void parse(Element node) {
if (!showThumbs) {
// do not show any thumbnails
return;
}
int count = node.getElementCount();
for (int i = 0; i < count; i++) {
Element elm = node.getElement(i);
Debug.log(8, elm.toString());
if (elm.isLeaf()) {
int start = elm.getStartOffset(), end = elm.getEndOffset();
parseRange(start, end);
} else {
parse(elm);
}
}
}
private void checkCompletion(java.awt.event.KeyEvent ke) throws BadLocationException {
Document doc = getDocument();
Element root = doc.getDefaultRootElement();
int pos = getCaretPosition();
int lineIdx = root.getElementIndex(pos);
Element line = root.getElement(lineIdx);
int start = line.getStartOffset(), len = line.getEndOffset() - start;
String strLine = doc.getText(start, len - 1);
Debug.log(9, "[" + strLine + "]");
if (strLine.endsWith("find") && ke.getKeyChar() == '(') {
ke.consume();
doc.insertString(pos, "(", null);
ButtonCapture btnCapture = new ButtonCapture(this, line);
insertComponent(btnCapture);
doc.insertString(pos + 2, ")", null);
}
}
void editorPane_keyPressed(KeyEvent e) {
StyledDocument doc = editorPane.getStyledDocument();
int pos = editorPane.getCaretPosition();
int code = e.getKeyCode();
Element el;
switch (code) {
case KeyEvent.VK_BACK_SPACE:
case KeyEvent.VK_DELETE:
case KeyEvent.VK_LEFT:
case KeyEvent.VK_KP_LEFT:
if (pos == 0) return;
// we want to get the element to the left of position.
el = doc.getCharacterElement(pos - 1);
break;
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_KP_RIGHT:
// we want to get the element to the right of position.
el = doc.getCharacterElement(pos + 1);
break;
default:
return; // bail we don't handle it.
}
AttributeSet attr = el.getAttributes();
String el_name = (String) attr.getAttribute(StyleConstants.NameAttribute);
int el_range = el.getEndOffset() - el.getStartOffset() - 1;
if (el_name.startsWith("Parameter") && StyleConstants.getComponent(attr) != null) {
try {
switch (code) {
case KeyEvent.VK_BACK_SPACE:
case KeyEvent.VK_DELETE:
doc.remove(el.getStartOffset(), el_range);
break;
case KeyEvent.VK_LEFT:
case KeyEvent.VK_KP_LEFT:
editorPane.setCaretPosition(pos - el_range);
break;
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_KP_RIGHT:
editorPane.setCaretPosition(pos + (el_range));
break;
}
} catch (BadLocationException ex) {
}
}
}
/** Returns the selected text, or null if no selection is active. */
public final String getSelectedText() {
if (selectionStart == selectionEnd) return null;
if (rectSelect) {
// Return each row of the selection on a new line
Element map = document.getDefaultRootElement();
int start = selectionStart - map.getElement(selectionStartLine).getStartOffset();
int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();
// Certain rectangles satisfy this condition...
if (end < start) {
int tmp = end;
end = start;
start = tmp;
}
StringBuffer buf = new StringBuffer();
Segment seg = new Segment();
for (int i = selectionStartLine; i <= selectionEndLine; i++) {
Element lineElement = map.getElement(i);
int lineStart = lineElement.getStartOffset();
int lineEnd = lineElement.getEndOffset() - 1;
int lineLen = lineEnd - lineStart;
lineStart = Math.min(lineStart + start, lineEnd);
lineLen = Math.min(end - start, lineEnd - lineStart);
getText(lineStart, lineLen, seg);
buf.append(seg.array, seg.offset, seg.count);
if (i != selectionEndLine) buf.append('\n');
}
return buf.toString();
} else {
return getText(selectionStart, selectionEnd - selectionStart);
}
}
private int getFunctionStartOffset(String func, Element node) throws BadLocationException {
Document doc = getDocument();
int count = node.getElementCount();
Pattern patDef = Pattern.compile("def\\s+" + func + "\\s*\\(");
for (int i = 0; i < count; i++) {
Element elm = node.getElement(i);
if (elm.isLeaf()) {
int start = elm.getStartOffset(), end = elm.getEndOffset();
String line = doc.getText(start, end - start);
Matcher matcher = patDef.matcher(line);
if (matcher.find()) {
return start;
}
} else {
int p = getFunctionStartOffset(func, elm);
if (p >= 0) {
return p;
}
}
}
return -1;
}
public void write(Writer out, Document doc, int pos, int len, Map<String, String> copiedImgs)
throws IOException, BadLocationException {
Debug.log(9, "SikuliEditorKit.write %d %d", pos, len);
DefaultStyledDocument sdoc = (DefaultStyledDocument) doc;
int i = pos;
String absPath;
while (i < pos + len) {
Element e = sdoc.getCharacterElement(i);
int start = e.getStartOffset(), end = e.getEndOffset();
if (e.getName().equals(StyleConstants.ComponentElementName)) {
// A image argument to be filled
AttributeSet attr = e.getAttributes();
Component com = StyleConstants.getComponent(attr);
out.write(com.toString());
if (copiedImgs != null
&& (com instanceof EditorPatternButton || com instanceof EditorPatternLabel)) {
if (com instanceof EditorPatternButton) {
absPath = ((EditorPatternButton) com).getFilename();
} else {
absPath = ((EditorPatternLabel) com).getFile();
}
String fname = (new File(absPath)).getName();
copiedImgs.put(fname, absPath);
Debug.log(3, "save image for copy&paste: " + fname + " -> " + absPath);
}
} else {
if (start < pos) {
start = pos;
}
if (end > pos + len) {
end = pos + len;
}
out.write(doc.getText(start, end - start));
}
i = end;
}
out.close();
}
/**
* Replaces the selection with the specified text.
*
* @param selectedText The replacement text for the selection
*/
public void setSelectedText(String selectedText) {
if (!editable) {
throw new InternalError("Text component" + " read only");
}
document.beginCompoundEdit();
try {
if (rectSelect) {
Element map = document.getDefaultRootElement();
int start = selectionStart - map.getElement(selectionStartLine).getStartOffset();
int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();
// Certain rectangles satisfy this condition...
if (end < start) {
int tmp = end;
end = start;
start = tmp;
}
int lastNewline = 0;
int currNewline = 0;
for (int i = selectionStartLine; i <= selectionEndLine; i++) {
Element lineElement = map.getElement(i);
int lineStart = lineElement.getStartOffset();
int lineEnd = lineElement.getEndOffset() - 1;
int rectStart = Math.min(lineEnd, lineStart + start);
document.remove(rectStart, Math.min(lineEnd - rectStart, end - start));
if (selectedText == null) continue;
currNewline = selectedText.indexOf('\n', lastNewline);
if (currNewline == -1) currNewline = selectedText.length();
document.insertString(rectStart, selectedText.substring(lastNewline, currNewline), null);
lastNewline = Math.min(selectedText.length(), currNewline + 1);
}
if (selectedText != null && currNewline != selectedText.length()) {
int offset = map.getElement(selectionEndLine).getEndOffset() - 1;
document.insertString(offset, "\n", null);
document.insertString(offset + 1, selectedText.substring(currNewline + 1), null);
}
} else {
document.remove(selectionStart, selectionEnd - selectionStart);
if (selectedText != null) {
document.insertString(selectionStart, selectedText, null);
}
}
} catch (BadLocationException bl) {
bl.printStackTrace();
throw new InternalError("Cannot replace" + " selection");
}
// No matter what happends... stops us from leaving document
// in a bad state
finally {
document.endCompoundEdit();
}
setCaretPosition(selectionEnd);
}
/**
* Returns the length of the specified line.
*
* @param line The line
*/
public int getLineLength(int line) {
Element lineElement = document.getDefaultRootElement().getElement(line);
if (lineElement == null) return -1;
else return lineElement.getEndOffset() - lineElement.getStartOffset() - 1;
}
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());
}
}