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 ""; }
public void focusGained(FocusEvent fe) { textComponent = (JTextComponent) fe.getSource(); attributeSet = textComponent.getDocument().getDefaultRootElement().getAttributes(); } };
@Nullable protected String getTextLineNumber(int rowStartOffset) { Element root = codeArea.getDocument().getDefaultRootElement(); int index = root.getElementIndex(rowStartOffset); Element line = root.getElement(index); if (line.getStartOffset() != rowStartOffset) { return null; } int lineNumber = index + 1; if (useSourceLines) { Integer sourceLine = codeArea.getSourceLine(lineNumber); if (sourceLine == null) { return null; } return String.valueOf(sourceLine); } return String.valueOf(lineNumber); }
private boolean isCurrentLine(int rowStartOffset) { int caretPosition = component.getCaretPosition(); Element root = component.getDocument().getDefaultRootElement(); return root.getElementIndex(rowStartOffset) == root.getElementIndex(caretPosition); }
@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; } }
private boolean isCurrentLine(int rowStartOffset) { int caretPosition = codeArea.getCaretPosition(); Element root = codeArea.getDocument().getDefaultRootElement(); return root.getElementIndex(rowStartOffset) == root.getElementIndex(caretPosition); }
@Override public void caretUpdate(CaretEvent e) { int caretPosition = codeArea.getCaretPosition(); Element root = codeArea.getDocument().getDefaultRootElement(); int currentLine = root.getElementIndex(caretPosition); if (lastLine != currentLine) { repaint(); lastLine = currentLine; } }
private void setPreferredWidth() { Element root = codeArea.getDocument().getDefaultRootElement(); int lines = root.getElementCount(); int digits = Math.max(String.valueOf(lines).length(), 3); 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(); if (d != null) { d.setSize(preferredWidth, NUM_HEIGHT); setPreferredSize(d); setSize(d); } } }
fonts = new HashMap<>(); Element root = codeArea.getDocument().getDefaultRootElement(); int index = root.getElementIndex(rowStartOffset); Element line = root.getElement(index);
/** * 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); } }
fonts = new HashMap<>(); Element root = component.getDocument().getDefaultRootElement(); int index = root.getElementIndex(rowStartOffset); Element line = root.getElement(index);
@Override public void paintComponent(Graphics g) { super.paintComponent(g); // starting position in document int start = textEditor.viewToModel(getViewport().getViewPosition()); // end position in document int end = textEditor.viewToModel(new Point(10, getViewport().getViewPosition().y + (int) textEditor.getVisibleRect().getHeight()) ); // translate offsets to lines Document doc = textEditor.getDocument(); int startline = doc.getDefaultRootElement().getElementIndex(start) + 1; int endline = doc.getDefaultRootElement().getElementIndex(end) + 1; Font f = textEditor.getFont(); int fontHeight = g.getFontMetrics(f).getHeight(); int fontDesc = g.getFontMetrics(f).getDescent(); int startingY = -1; try { startingY = textEditor.modelToView(start).y + fontHeight - fontDesc; } catch (BadLocationException e1) { System.err.println(e1.getMessage()); } g.setFont(f); for (int line = startline, y = startingY; line <= endline; y += fontHeight, line++) { String lineNumber = StringGroovyMethods.padLeft(Integer.toString(line), 4, " "); g.drawString(lineNumber, 0, y); } } }
/** * Get index of line for current offset (generally cursor position). * @param offset Position on the line * @return Index of the line * @throws BadLocationException */ public int getLineOfOffset(int offset) throws BadLocationException { String errorMsg = "Can't translate offset to line"; Document doc = this.getDocument(); if (offset < 0) { throw new BadLocationException(errorMsg, -1); } else if (offset > doc.getLength()) { throw new BadLocationException(errorMsg, doc.getLength() + 1); } else { Element map = doc.getDefaultRootElement(); return map.getElementIndex(offset); } }
private static Element getLineElem(Document d, int offs) { Element map = d.getDefaultRootElement(); int index = map.getElementIndex(offs); Element elem = map.getElement(index); if ((offs>=elem.getStartOffset()) && (offs<elem.getEndOffset())) { return elem; } return null; }
private void doError(SAXParseException e, ParserNotice.Level level) { int line = e.getLineNumber() - 1; Element root = doc.getDefaultRootElement(); Element elem = root.getElement(line); int offs = elem.getStartOffset(); int len = elem.getEndOffset() - offs; if (line==root.getElementCount()-1) { len++; } DefaultParserNotice pn = new DefaultParserNotice(XmlParser.this, e.getMessage(), line, offs, len); pn.setLevel(level); result.addNotice(pn); }
/** * Returns the leading whitespace of a specific line in a document. * * @param doc The document. * @param offs The offset whose line to get the leading whitespace for. * @return The leading whitespace. * @throws BadLocationException If <code>offs</code> is not a valid offset * in the document. * @see #getLeadingWhitespace(String) */ public static String getLeadingWhitespace(Document doc, int offs) throws BadLocationException { Element root = doc.getDefaultRootElement(); int line = root.getElementIndex(offs); Element elem = root.getElement(line); int startOffs = elem.getStartOffset(); int endOffs = elem.getEndOffset() - 1; String text = doc.getText(startOffs, endOffs-startOffs); return getLeadingWhitespace(text); }
/** * Returns whether the specified offset is "inside" the fold. This method * returns <code>true</code> if the offset is greater than the fold start * offset, and no further than the last offset of the last folded line. * * @param offs The offset to check. * @return Whether the offset is "inside" the fold. * @see #containsLine(int) */ public boolean containsOffset(int offs) { boolean contained = false; if (offs>getStartOffset()) { // Use Elements to avoid BadLocationExceptions Element root = textArea.getDocument().getDefaultRootElement(); int line = root.getElementIndex(offs); contained = line<=getEndLine(); } return contained; }
/** * Get position of the beginning of the line. * @param line Index of the line * @return Offset of line * @throws BadLocationException */ public int getLineStartOffset(int line) throws BadLocationException { Element map = this.getDocument().getDefaultRootElement(); if (line < 0) { throw new BadLocationException("Negative line", -1); } else if (line >= map.getElementCount()) { throw new BadLocationException("No such line", this.getDocument().getLength() + 1); } else { Element lineElem = map.getElement(line); return lineElem.getStartOffset(); } }
@Override public void actionPerformedImpl(ActionEvent e, RTextArea textArea) { try { // We use the elements instead of calling getLineOfOffset(), // etc. to speed things up just a tad (i.e. micro-optimize). Document document = textArea.getDocument(); int caretPosition = textArea.getCaretPosition(); Element map = document.getDefaultRootElement(); int currentLineNum = map.getElementIndex(caretPosition); Element currentLineElement = map.getElement(currentLineNum); // Always take -1 as we don't want to remove the newline. int currentLineEnd = currentLineElement.getEndOffset()-1; if (caretPosition<currentLineEnd) { document.remove(caretPosition, currentLineEnd-caretPosition); } } catch (BadLocationException ble) { ble.printStackTrace(); } }
@Override public void insertUpdate(DocumentEvent e) { // Adding text containing a newline to the visible line of a folded // Fold causes that Fold to unfold. Check only start offset of // insertion since that's the line that was "modified". int startOffs = e.getOffset(); int endOffs = startOffs + e.getLength(); Document doc = e.getDocument(); Element root = doc.getDefaultRootElement(); int startLine = root.getElementIndex(startOffs); int endLine = root.getElementIndex(endOffs); if (startLine!=endLine) { // Inserted text covering > 1 line... Fold fold = getFoldForLine(startLine); if (fold!=null && fold.isCollapsed()) { fold.toggleCollapsedState(); } } }