@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);
}
/**
* Provides a mapping from the view coordinate space to the logical coordinate space of the model.
*
* @param fx the X coordinate >= 0
* @param fy the Y coordinate >= 0
* @param a the allocated region to render into
* @return the location within the model that best represents the given point in the view >= 0
*/
@Override
public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {
bias[0] = Position.Bias.Forward;
Rectangle alloc = a.getBounds();
RSyntaxDocument doc = (RSyntaxDocument) getDocument();
int x = (int) fx;
int y = (int) fy;
// If they're asking about a view position above the area covered by
// this view, then the position is assumed to be the starting position
// of this view.
if (y < alloc.y) {
return getStartOffset();
}
// If they're asking about a position below this view, the position
// is assumed to be the ending position of this view.
else if (y > alloc.y + alloc.height) {
return host.getLastVisibleOffset();
}
// They're asking about a position within the coverage of this view
// vertically. So, we figure out which line the point corresponds to.
// If the line is greater than the number of lines contained, then
// simply use the last line as it represents the last possible place
// we can position to.
else {
Element map = doc.getDefaultRootElement();
int lineIndex = Math.abs((y - alloc.y) / lineHeight); // metrics.getHeight() );
FoldManager fm = host.getFoldManager();
// System.out.print("--- " + lineIndex);
lineIndex += fm.getHiddenLineCountAbove(lineIndex, true);
// System.out.println(" => " + lineIndex);
if (lineIndex >= map.getElementCount()) {
return host.getLastVisibleOffset();
}
Element line = map.getElement(lineIndex);
// If the point is to the left of the line...
if (x < alloc.x) {
return line.getStartOffset();
} else if (x > alloc.x + alloc.width) {
return line.getEndOffset() - 1;
} else {
// Determine the offset into the text
int p0 = line.getStartOffset();
Token tokenList = doc.getTokenListForLine(lineIndex);
tabBase = alloc.x;
int offs = tokenList.getListOffset((RSyntaxTextArea) getContainer(), this, tabBase, x);
return offs != -1 ? offs : p0;
}
} // End of else.
}
/**
* Returns the line.
*
* @param content the content
* @param offset the offset to start at
* @return the line
*/
protected String getLine(String content, int offset) {
int line = m_RootElement.getElementIndex(offset);
Element lineElement = m_RootElement.getElement(line);
int start = lineElement.getStartOffset();
int end = lineElement.getEndOffset();
return content.substring(start, end - 1);
}
/**
* Highlight lines to start or end delimiter.
*
* @param content the content to parse
* @param line the line number
* @throws BadLocationException if offsets are wrong
*/
protected void highlightLinesAfter(String content, int line) throws BadLocationException {
int offset = m_RootElement.getElement(line).getEndOffset();
// Start/End delimiter not found, nothing to do
int startDelimiter = -1;
int endDelimiter = -1;
if (getMultiLineComment()) {
startDelimiter = indexOf(content, getMultiLineCommentStart(), offset);
endDelimiter = indexOf(content, getMultiLineCommentEnd(), offset);
}
if (startDelimiter < 0) startDelimiter = content.length();
if (endDelimiter < 0) endDelimiter = content.length();
int delimiter = Math.min(startDelimiter, endDelimiter);
if (delimiter < offset) return;
// Start/End delimiter found, reapply highlighting
int endLine = m_RootElement.getElementIndex(delimiter);
for (int i = line + 1; i < endLine; i++) {
Element branch = m_RootElement.getElement(i);
Element leaf = m_Self.getCharacterElement(branch.getStartOffset());
AttributeSet as = leaf.getAttributes();
if (as.isEqual(DEFAULT_COMMENT)) applyHighlighting(content, i);
}
}
/**
* Paints the word-wrapped text.
*
* @param g The graphics context in which to paint.
* @param a The shape (usually a rectangle) in which to paint.
*/
public void paint(Graphics g, Shape a) {
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();
tabBase = alloc.x;
Graphics2D g2d = (Graphics2D) g;
host = (RSyntaxTextArea) getContainer();
int ascent = host.getMaxAscent();
int fontHeight = host.getLineHeight();
FoldManager fm = host.getFoldManager();
TokenPainter painter = host.getTokenPainter();
Element root = getElement();
// Whether token styles should always be painted, even in selections
int selStart = host.getSelectionStart();
int selEnd = host.getSelectionEnd();
boolean useSelectedTextColor = host.getUseSelectedTextColor();
int n = getViewCount(); // Number of lines.
int x = alloc.x + getLeftInset();
tempRect.y = alloc.y + getTopInset();
Rectangle clip = g.getClipBounds();
for (int i = 0; i < n; i++) {
tempRect.x = x + getOffset(X_AXIS, i);
// tempRect.y = y + getOffset(Y_AXIS, i);
tempRect.width = getSpan(X_AXIS, i);
tempRect.height = getSpan(Y_AXIS, i);
// System.err.println("For line " + i + ": tempRect==" + tempRect);
if (tempRect.intersects(clip)) {
Element lineElement = root.getElement(i);
int startOffset = lineElement.getStartOffset();
int endOffset = lineElement.getEndOffset() - 1; // Why always "-1"?
View view = getView(i);
if (!useSelectedTextColor
|| selStart == selEnd
|| (startOffset >= selEnd || endOffset < selStart)) {
drawView(painter, g2d, alloc, view, fontHeight, tempRect.y + ascent);
} else {
// System.out.println("Drawing line with selection: " + i);
drawViewWithSelection(
painter, g2d, alloc, view, fontHeight, tempRect.y + ascent, selStart, selEnd);
}
}
tempRect.y += tempRect.height;
Fold possibleFold = fm.getFoldForLine(i);
if (possibleFold != null && possibleFold.isCollapsed()) {
i += possibleFold.getCollapsedLineCount();
// Visible indicator of collapsed lines
Color c = RSyntaxUtilities.getFoldedLineBottomColor(host);
if (c != null) {
g.setColor(c);
g.drawLine(x, tempRect.y - 1, alloc.width, tempRect.y - 1);
}
}
}
}
/* */ protected void drawLine(
int paramInt1, int paramInt2, Graphics paramGraphics, int paramInt3, int paramInt4)
/* */ {
/* 105 */ Element localElement1 = getElement();
/* 106 */ Element localElement2 =
localElement1.getElement(localElement1.getElementIndex(paramInt1));
/* */ try
/* */ {
/* 110 */ if (localElement2.isLeaf()) {
/* 111 */ drawText(
localElement2, paramInt1, paramInt2, paramGraphics, paramInt3, paramInt4);
/* */ }
/* */ else {
/* 114 */ int i = localElement2.getElementIndex(paramInt1);
/* 115 */ int j = localElement2.getElementIndex(paramInt2);
/* 116 */ for (; i <= j; i++) {
/* 117 */ Element localElement3 = localElement2.getElement(i);
/* 118 */ int k = Math.max(localElement3.getStartOffset(), paramInt1);
/* 119 */ int m = Math.min(localElement3.getEndOffset(), paramInt2);
/* 120 */ paramInt3 = drawText(localElement3, k, m, paramGraphics, paramInt3, paramInt4);
/* */ }
/* */ }
/* */ } catch (BadLocationException localBadLocationException) {
/* 124 */ throw new StateInvariantError("Can't render: " + paramInt1 + "," + paramInt2);
/* */ }
/* */ }
/**
* Writes out text. If a range is specified when the constructor is invoked, then only the
* appropriate range of text is written out.
*
* @param elem an Element
* @exception IOException on any I/O error
* @exception BadLocationException if pos represents an invalid location within the document.
*/
protected void text(Element elem) throws BadLocationException, IOException {
int start = Math.max(getStartOffset(), elem.getStartOffset());
int end = Math.min(getEndOffset(), elem.getEndOffset());
if (start < end) {
if (segment == null) {
segment = new Segment();
}
getDocument().getText(start, end - start, segment);
newlineOutputed = false;
if (segment.count > 0) {
if (segment.array[segment.offset + segment.count - 1] == '\n') {
newlineOutputed = true;
}
if (inPre && end == preEndOffset) {
if (segment.count > 1) {
segment.count--;
} else {
return;
}
}
replaceEntities = true;
setCanWrapLines(!inPre);
write(segment.array, segment.offset, segment.count);
setCanWrapLines(false);
replaceEntities = false;
}
}
}
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;
}
/**
* Create a new AbstractWriter with the indicated Writer and Element. The full range of the
* Element will be used.
*/
protected AbstractWriter(Writer writer, Element elt) {
this.writer = writer;
this.iter = new ElementIterator(elt);
this.document = elt.getDocument();
this.startOffset = elt.getStartOffset();
this.endOffset = elt.getEndOffset();
}
/* */ private int drawText(
Element paramElement,
int paramInt1,
int paramInt2,
Graphics paramGraphics,
int paramInt3,
int paramInt4)
throws BadLocationException {
/* 129 */ paramInt2 = Math.min(getDocument().getLength(), paramInt2);
/* 130 */ AttributeSet localAttributeSet = paramElement.getAttributes();
/* */
/* 132 */ if (Utilities.isComposedTextAttributeDefined(localAttributeSet)) {
/* 133 */ paramGraphics.setColor(this.unselected);
/* 134 */ paramInt3 =
Utilities.drawComposedText(
this,
localAttributeSet,
paramGraphics,
paramInt3,
paramInt4,
paramInt1 - paramElement.getStartOffset(),
paramInt2 - paramElement.getStartOffset());
/* */ }
/* 138 */ else if ((this.sel0 == this.sel1) || (this.selected == this.unselected))
/* */ {
/* 140 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, paramInt1, paramInt2);
/* 141 */ } else if ((paramInt1 >= this.sel0)
&& (paramInt1 <= this.sel1)
&& (paramInt2 >= this.sel0)
&& (paramInt2 <= this.sel1)) {
/* 142 */ paramInt3 =
drawSelectedText(paramGraphics, paramInt3, paramInt4, paramInt1, paramInt2);
/* 143 */ } else if ((this.sel0 >= paramInt1) && (this.sel0 <= paramInt2)) {
/* 144 */ if ((this.sel1 >= paramInt1) && (this.sel1 <= paramInt2)) {
/* 145 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, paramInt1, this.sel0);
/* 146 */ paramInt3 =
drawSelectedText(paramGraphics, paramInt3, paramInt4, this.sel0, this.sel1);
/* 147 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, this.sel1, paramInt2);
/* */ } else {
/* 149 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, paramInt1, this.sel0);
/* 150 */ paramInt3 =
drawSelectedText(paramGraphics, paramInt3, paramInt4, this.sel0, paramInt2);
/* */ }
/* 152 */ } else if ((this.sel1 >= paramInt1) && (this.sel1 <= paramInt2)) {
/* 153 */ paramInt3 =
drawSelectedText(paramGraphics, paramInt3, paramInt4, paramInt1, this.sel1);
/* 154 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, this.sel1, paramInt2);
/* */ } else {
/* 156 */ paramInt3 =
drawUnselectedText(paramGraphics, paramInt3, paramInt4, paramInt1, paramInt2);
/* */ }
/* */
/* 160 */ return paramInt3;
/* */ }
/*
* 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 "";
}
/**
* Output the text of the indicated Element, properly clipping it to the range of the Document
* specified when the AbstractWriter was created.
*/
protected void text(Element elt) throws BadLocationException, IOException {
int eltStart = elt.getStartOffset();
int eltEnd = elt.getEndOffset();
eltStart = Math.max(eltStart, startOffset);
eltEnd = Math.min(eltEnd, endOffset);
write(document.getText(eltStart, eltEnd));
}
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) {
}
}
}
public int getLineStartOffset(int line) throws BadLocationException {
// line starting from 0
Element map = getDocument().getDefaultRootElement();
if (line < 0) {
throw new BadLocationException("Negative line", -1);
} else if (line >= map.getElementCount()) {
throw new BadLocationException("No such line", getDocument().getLength() + 1);
} else {
Element lineElem = map.getElement(line);
return lineElem.getStartOffset();
}
}
/** 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;
}
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);
}
}
/**
* Returns a token list for the specified segment of text representing the specified line number.
* This method is basically a wrapper for <code>tokenMaker.getTokenList</code> that takes into
* account the last token on the previous line to assure token accuracy.
*
* @param line The line number of <code>text</code> in the document, >= 0.
* @return A token list representing the specified line.
*/
public final Token getTokenListForLine(int line) {
Element map = getDefaultRootElement();
Element elem = map.getElement(line);
int startOffset = elem.getStartOffset();
// int endOffset = (line==map.getElementCount()-1 ? elem.getEndOffset() - 1:
// elem.getEndOffset() - 1);
int endOffset = elem.getEndOffset() - 1; // Why always "-1"?
try {
getText(startOffset, endOffset - startOffset, s);
} catch (BadLocationException ble) {
ble.printStackTrace();
return null;
}
int initialTokenType = line == 0 ? Token.NULL : getLastTokenTypeOnLine(line - 1);
return tokenMaker.getTokenList(s, initialTokenType, startOffset);
}
/**
* Makes our private <code>Segment s</code> point to the text in our document referenced by the
* specified element. Note that <code>line</code> MUST be a valid line number in the document.
*
* @param line The line number you want to get.
*/
private final void setSharedSegment(int line) {
Element map = getDefaultRootElement();
// int numLines = map.getElementCount();
Element element = map.getElement(line);
if (element == null) throw new InternalError("Invalid line number: " + line);
int startOffset = element.getStartOffset();
// int endOffset = (line==numLines-1 ?
// element.getEndOffset()-1 : element.getEndOffset() - 1);
int endOffset = element.getEndOffset() - 1; // Why always "-1"?
try {
getText(startOffset, endOffset - startOffset, s);
} catch (BadLocationException ble) {
throw new InternalError("Text range not in document: " + startOffset + "-" + endOffset);
}
}
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);
}
}
/** 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);
}
}
/**
* Scrolls the help browser to the element with id <code>id</code>
*
* @param id the id
* @return true, if an element with this id was found and scrolling was successful; false,
* otherwise
*/
protected boolean scrollToElementWithId(String id) {
Document d = help.getDocument();
if (d instanceof HTMLDocument) {
HTMLDocument doc = (HTMLDocument) d;
Element element = doc.getElement(id);
try {
Rectangle r = help.modelToView(element.getStartOffset());
if (r != null) {
Rectangle vis = help.getVisibleRect();
r.height = vis.height;
help.scrollRectToVisible(r);
return true;
}
} catch (BadLocationException e) {
System.err.println(
tr("Warning: bad location in HTML document. Exception was: {0}", e.toString()));
e.printStackTrace();
}
}
return false;
}
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 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);
}
}
}
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();
}
/** Return true if the Element's range overlaps our desired output range; false otherwise. */
protected boolean inRange(Element elt) {
int eltStart = elt.getStartOffset();
int eltEnd = elt.getEndOffset();
return ((eltStart >= startOffset && eltStart < endOffset)
|| (eltEnd >= startOffset && eltEnd < endOffset));
}
