/**
* Ensures that the specified line and offset is visible by scrolling the text area if necessary.
*
* @param line The line to scroll to
* @param offset The offset in the line to scroll to
* @return True if scrolling was actually performed, false if the line and offset was already
* visible
*/
public boolean scrollTo(int line, int offset) {
// visibleLines == 0 before the component is realized
// we can't do any proper scrolling then, so we have
// this hack...
if (visibleLines == 0) {
setFirstLine(Math.max(0, line - electricScroll));
return true;
}
int newFirstLine = firstLine;
int newHorizontalOffset = horizontalOffset;
if (line < firstLine + electricScroll) {
newFirstLine = Math.max(0, line - electricScroll);
} else if (line + electricScroll >= firstLine + visibleLines) {
newFirstLine = (line - visibleLines) + electricScroll + 1;
if (newFirstLine + visibleLines >= getLineCount())
newFirstLine = getLineCount() - visibleLines;
if (newFirstLine < 0) newFirstLine = 0;
}
int x = _offsetToX(line, offset);
int width = painter.getFontMetrics().charWidth('w');
if (x < 0) {
newHorizontalOffset = Math.min(0, horizontalOffset - x + width + 5);
} else if (x + width >= painter.getWidth()) {
newHorizontalOffset = horizontalOffset + (painter.getWidth() - x) - width - 5;
}
return setOrigin(newFirstLine, newHorizontalOffset);
}
/**
* Damages the area surrounding the caret to cause it to be repainted in a new location. If
* paint() is reimplemented, this method should also be reimplemented. This method should update
* the caret bounds (x, y, width, and height).
*
* @param r the current location of the caret
* @see #paint
*/
@Override
protected synchronized void damage(final Rectangle r) {
if (r == null || fPainting) return;
x = r.x - 4;
y = r.y;
width = 10;
height = r.height;
// Don't damage the border area. We can't paint a partial border, so get the
// intersection of the caret rectangle and the component less the border, if any.
final Rectangle caretRect = new Rectangle(x, y, width, height);
final Border border = getComponent().getBorder();
if (border != null) {
final Rectangle alloc = getComponent().getBounds();
alloc.x = alloc.y = 0;
final Insets borderInsets = border.getBorderInsets(getComponent());
alloc.x += borderInsets.left;
alloc.y += borderInsets.top;
alloc.width -= borderInsets.left + borderInsets.right;
alloc.height -= borderInsets.top + borderInsets.bottom;
Rectangle2D.intersect(caretRect, alloc, caretRect);
}
x = caretRect.x;
y = caretRect.y;
width = Math.max(caretRect.width, 1);
height = Math.max(caretRect.height, 1);
repaint();
}
/**
* Performs layout for the minor axis of the box (i.e. the axis orthogonal to the axis that it
* represents). The results of the layout (the offset and span for each children) are placed in
* the given arrays which represent the allocations to the children along the minor axis.
*
* @param targetSpan the total span given to the view, which would be used to layout the children.
* @param axis the axis being layed out
* @param offsets the offsets from the origin of the view for each of the child views; this is a
* return value and is filled in by the implementation of this method
* @param spans the span of each child view; this is a return value and is filled in by the
* implementation of this method
*/
protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
int n = getViewCount();
Object key = (axis == X_AXIS) ? CSS.Attribute.WIDTH : CSS.Attribute.HEIGHT;
for (int i = 0; i < n; i++) {
View v = getView(i);
int min = (int) v.getMinimumSpan(axis);
int max;
// check for percentage span
AttributeSet a = v.getAttributes();
CSS.LengthValue lv = (CSS.LengthValue) a.getAttribute(key);
if ((lv != null) && lv.isPercentage()) {
// bound the span to the percentage specified
min = Math.max((int) lv.getValue(targetSpan), min);
max = min;
} else {
max = (int) v.getMaximumSpan(axis);
}
// assign the offset and span for the child
if (max < targetSpan) {
// can't make the child this wide, align it
float align = v.getAlignment(axis);
offsets[i] = (int) ((targetSpan - max) * align);
spans[i] = max;
} else {
// make it the target width, or as small as it can get.
offsets[i] = 0;
spans[i] = Math.max(min, targetSpan);
}
}
}
/**
* Writes the <code>shape</code>, <code>coords</code>, <code>href</code>,
* <code>nohref</code> Attribute for the specified figure and ellipse.
*
* @return Returns true, if the circle is inside of the image bounds.
*/
private boolean writeCircleAttributes(IXMLElement elem, SVGFigure f, Ellipse2D.Double ellipse) {
AffineTransform t = TRANSFORM.getClone(f);
if (t == null) {
t = drawingTransform;
} else {
t.preConcatenate(drawingTransform);
}
if ((t.getType() &
(AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) ==
t.getType() &&
ellipse.width == ellipse.height
) {
Point2D.Double start = new Point2D.Double(ellipse.x, ellipse.y);
Point2D.Double end = new Point2D.Double(ellipse.x + ellipse.width, ellipse.y + ellipse.height);
t.transform(start, start);
t.transform(end, end);
ellipse.x = Math.min(start.x, end.x);
ellipse.y = Math.min(start.y, end.y);
ellipse.width = Math.abs(start.x - end.x);
ellipse.height = Math.abs(start.y - end.y);
elem.setAttribute("shape", "circle");
elem.setAttribute("coords",
(int) (ellipse.x + ellipse.width / 2d)+","+
(int) (ellipse.y + ellipse.height / 2d)+","+
(int) (ellipse.width / 2d)
);
writeHrefAttribute(elem, f);
return bounds.intersects(ellipse.getBounds());
} else {
return writePolyAttributes(elem, f, (Shape) ellipse);
}
}
/**
* 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 void execute() {
if (!isEditable() || !isEnabled()) {
return;
}
try {
int position = lastClickPoint != null ? viewToModel(lastClickPoint) : getCaretPosition();
lastClickPoint = null;
Document document = getDocument();
String selectedText = getSelectedText();
if (selectedText != null && !CommonUtil.isEmpty(selectedText)) {
final int selectionEnd = getSelectionEnd();
document.insertString(selectionEnd, selectedText, null);
select(selectionEnd, selectionEnd + selectedText.length());
} else {
final int docLen = document.getLength();
int fromIndex = Math.max(0, getText(0, position).lastIndexOf('\n'));
int toIndex = getText(fromIndex + 1, docLen - fromIndex).indexOf('\n');
toIndex = toIndex < 0 ? docLen : fromIndex + toIndex;
String textToDuplicate = getText(fromIndex, toIndex - fromIndex + 1);
if (!textToDuplicate.startsWith("\n")) {
textToDuplicate = "\n" + textToDuplicate;
}
if (textToDuplicate.endsWith("\n")) {
textToDuplicate = textToDuplicate.substring(0, textToDuplicate.length() - 1);
}
document.insertString(Math.min(docLen, toIndex + 1), textToDuplicate, null);
setCaretPosition(position + textToDuplicate.length());
}
} catch (BadLocationException e1) {
e1.printStackTrace();
}
}
/**
* Replaces the currently selected content with new content represented by the given StyledText.
* If there is no selection this amounts to an insert of the given text. If there is no
* replacement text this amounts to a removal of the current selection. The replacement text will
* have the attributes currently defined for input at the point of insertion. If the document is
* not editable, beep and return
*
* @param content the content to replace the selection with
* @see StyledText#insert
*/
public static void replaceSelection(Word word, StyledText content) {
Document doc = word.workspace.getDocument();
String text;
Caret caret = word.workspace.getCaret();
int insertPos = 0;
int i;
int contentSize;
if (doc != null) {
try {
int p0 = Math.min(caret.getDot(), caret.getMark());
int p1 = Math.max(caret.getDot(), caret.getMark());
// if there is any selection
if (p0 != p1) {
doc.remove(p0, p1 - p0);
}
// insert the content
if (content != null) {
content.insert(doc, p0);
}
} catch (BadLocationException ble) {
javax.swing.UIManager.getLookAndFeel().provideErrorFeedback(word.workspace);
return;
}
}
}
public void mouseClicked(MouseEvent e) {
int x;
int y;
e.consume();
if (mouseEventsEnabled) {
x = Math.round(e.getX() / scale);
y = Math.round(e.getY() / scale);
// allow for the canvas margin
y -= margin;
// System.out.println("Mouse Click: (" + x + ", " + y + ")");
if (e.getClickCount() < 2) {
if (nativeSelectItem(x, y)) {
parentFTAFrame.updateFrame();
}
} else {
if (nativeSelectItem(x, y)) {
parentFTAFrame.updateFrame();
}
editSelected();
parentFTAFrame.updateFrame();
}
if (focusEventsEnabled) {
// tell the main Canvas to point to this coordinate
parentFTAFrame.setCanvasFocus(x, y);
}
}
}
/**
* Ensures that the caret is visible by scrolling the text area if necessary.
*
* @return True if scrolling was actually performed, false if the caret was already visible
*/
public boolean scrollToCaret() {
int line = getCaretLine();
int lineStart = getLineStartOffset(line);
int offset = Math.max(0, Math.min(getLineLength(line) - 1, getCaretPosition() - lineStart));
return scrollTo(line, offset);
}
protected void paintLineHighlight(Graphics gfx, int line, int y) {
int height = fm.getHeight();
y += fm.getLeading() + fm.getMaxDescent();
int selectionStart = textArea.getSelectionStart();
int selectionEnd = textArea.getSelectionStop();
if (selectionStart == selectionEnd) {
if (lineHighlight) {
gfx.setColor(lineHighlightColor);
gfx.fillRect(0, y, getWidth(), height);
}
} else {
gfx.setColor(selectionColor);
int selectionStartLine = textArea.getSelectionStartLine();
int selectionEndLine = textArea.getSelectionStopLine();
int lineStart = textArea.getLineStartOffset(line);
int x1, x2;
if (textArea.isSelectionRectangular()) {
int lineLen = textArea.getLineLength(line);
x1 =
textArea._offsetToX(
line,
Math.min(
lineLen, selectionStart - textArea.getLineStartOffset(selectionStartLine)));
x2 =
textArea._offsetToX(
line,
Math.min(lineLen, selectionEnd - textArea.getLineStartOffset(selectionEndLine)));
if (x1 == x2) x2++;
} else if (selectionStartLine == selectionEndLine) {
x1 = textArea._offsetToX(line, selectionStart - lineStart);
x2 = textArea._offsetToX(line, selectionEnd - lineStart);
} else if (line == selectionStartLine) {
x1 = textArea._offsetToX(line, selectionStart - lineStart);
x2 = getWidth();
} else if (line == selectionEndLine) {
// x1 = 0;
// hack from stendahl to avoid doing weird side selection thing
x1 = textArea._offsetToX(line, 0);
// attempt at getting the gutter too, but doesn't seem to work
// x1 = textArea._offsetToX(line, -textArea.getHorizontalOffset());
x2 = textArea._offsetToX(line, selectionEnd - lineStart);
} else {
// x1 = 0;
// hack from stendahl to avoid doing weird side selection thing
x1 = textArea._offsetToX(line, 0);
// attempt at getting the gutter too, but doesn't seem to work
// x1 = textArea._offsetToX(line, -textArea.getHorizontalOffset());
x2 = getWidth();
}
// "inlined" min/max()
gfx.fillRect(x1 > x2 ? x2 : x1, y, x1 > x2 ? (x1 - x2) : (x2 - x1), height);
}
}
public void nudge(int i) {
x[i] += (double) rand.nextInt(1000) / 8756;
y[i] += (double) rand.nextInt(1000) / 5432;
int tmpScale = (int) (Math.abs(Math.sin(x[i])) * 10);
scale[i] = (double) tmpScale / 10;
int nudgeX = (int) (((double) getWidth() / 2) * .8);
int nudgeY = (int) (((double) getHeight() / 2) * .60);
xh[i] = (int) (Math.sin(x[i]) * nudgeX) + nudgeX;
yh[i] = (int) (Math.sin(y[i]) * nudgeY) + nudgeY;
}
void returnResponse() {
try {
int p = Math.min(initialPos, run.getDocument().getLength());
int l =
Math.min(run.getDocument().getLength() - p, maxLen >= 0 ? maxLen : Integer.MAX_VALUE);
resultQueue.offer(run.getText(p, l));
} catch (BadLocationException ex) {
// this cannot happen
resultQueue.offer("");
}
}
public void replaceSelection(String s) {
AutoDocument doc = (AutoDocument) getDocument();
if (doc == null) return;
try {
int i = Math.min(getCaret().getDot(), getCaret().getMark());
int j = Math.max(getCaret().getDot(), getCaret().getMark());
doc.replace(i, j - i, s, null);
} catch (Exception exception) {
}
}
public void animate(float[] pts, float[] deltas, int index, int limit) {
float newpt = pts[index] + deltas[index];
if (newpt <= 0) {
newpt = -newpt;
deltas[index] = (float) (Math.random() * 3.0 + 2.0);
} else if (newpt >= (float) limit) {
newpt = 2.0f * limit - newpt;
deltas[index] = -(float) (Math.random() * 3.0 + 2.0);
}
pts[index] = newpt;
}
public void execute() {
if (!isEditable() || !isEnabled()) {
return;
}
int position = lastClickPoint != null ? viewToModel(lastClickPoint) : getCaretPosition();
lastClickPoint = null;
Document document = getDocument();
String selectedText = getSelectedText();
try {
if (selectedText != null && !CommonUtil.isEmpty(selectedText)) {
String trimmed = selectedText.trim();
if (trimmed.startsWith("<!--") && trimmed.endsWith("-->")) {
StringBuffer buffer = new StringBuffer(selectedText);
int pos = buffer.indexOf("<!--");
buffer.delete(pos, pos + 4);
pos = buffer.lastIndexOf("-->");
buffer.delete(pos, pos + 3);
replaceSelection(buffer.toString());
} else {
String newSelection = "<!--" + selectedText + "-->";
replaceSelection(newSelection);
}
} else {
final int docLen = document.getLength();
int fromIndex = Math.max(0, getText(0, position).lastIndexOf('\n'));
int toIndex = getText(fromIndex + 1, docLen - position).indexOf('\n');
toIndex = toIndex < 0 ? docLen : fromIndex + toIndex;
String textToComment = getText(fromIndex, toIndex - fromIndex + 1);
if (textToComment.startsWith("\n")) {
textToComment = textToComment.substring(1);
fromIndex++;
}
if (textToComment.endsWith("\n")) {
textToComment = textToComment.substring(0, textToComment.length() - 1);
toIndex--;
}
String trimmed = textToComment.trim();
if (trimmed.startsWith("<!--") && trimmed.endsWith("-->")) {
int pos = textToComment.lastIndexOf("-->");
document.remove(fromIndex + pos, 3);
pos = textToComment.indexOf("<!--");
document.remove(fromIndex + pos, 4);
} else {
document.insertString(Math.min(toIndex + 1, docLen), "-->", null);
document.insertString(fromIndex, "<!--", null);
}
}
} catch (BadLocationException e1) {
e1.printStackTrace();
}
}
private Line addLine(Point p1, Point p2) {
if (Math.abs(p1.getX() - p2.getX()) < 5 || Math.abs(p1.getY() - p2.getY()) < 5) {
return null;
}
Line line = null;
if (p1 != null && p2 != null) {
line = new Line(p1, p2);
canvas.add(line);
}
repaint();
return line;
}
public static BufferedImage scaleImage(BufferedImage bi, double scale) {
int w1 = (int) (Math.round(scale * bi.getWidth()));
int h1 = (int) (Math.round(scale * bi.getHeight()));
BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w1, h1);
g2.drawImage(bi, 0, 0, w1, h1, null); // this);
g2.dispose();
return image;
}
protected void paintLineHighlight(Graphics gfx, int line, int y) {
int height = fm.getHeight();
y += fm.getLeading() + fm.getMaxDescent();
int selectionStart = textArea.getSelectionStart();
int selectionEnd = textArea.getSelectionEnd();
if (selectionStart == selectionEnd) {
if (lineHighlight) {
gfx.setColor(lineHighlightColor);
gfx.fillRect(0, y, getWidth(), height);
}
} else {
gfx.setColor(selectionColor);
int selectionStartLine = textArea.getSelectionStartLine();
int selectionEndLine = textArea.getSelectionEndLine();
int lineStart = textArea.getLineStartOffset(line);
int x1, x2;
if (textArea.isSelectionRectangular()) {
int lineLen = textArea.getLineLength(line);
x1 =
textArea._offsetToX(
line,
Math.min(
lineLen, selectionStart - textArea.getLineStartOffset(selectionStartLine)));
x2 =
textArea._offsetToX(
line,
Math.min(lineLen, selectionEnd - textArea.getLineStartOffset(selectionEndLine)));
if (x1 == x2) x2++;
} else if (selectionStartLine == selectionEndLine) {
x1 = textArea._offsetToX(line, selectionStart - lineStart);
x2 = textArea._offsetToX(line, selectionEnd - lineStart);
} else if (line == selectionStartLine) {
x1 = textArea._offsetToX(line, selectionStart - lineStart);
x2 = getWidth();
} else if (line == selectionEndLine) {
x1 = 0;
x2 = textArea._offsetToX(line, selectionEnd - lineStart);
} else {
x1 = 0;
x2 = getWidth();
}
// "inlined" min/max()
gfx.fillRect(x1 > x2 ? x2 : x1, y, x1 > x2 ? (x1 - x2) : (x2 - x1), height);
}
}
/**
* 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);
}
}
public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
if (!isAllocationValid()) {
Rectangle alloc = a.getBounds();
setSize(alloc.width, alloc.height);
}
boolean isBackward = (b == Position.Bias.Backward);
int testPos = (isBackward) ? Math.max(0, pos - 1) : pos;
if (isBackward && testPos < getStartOffset()) {
return null;
}
int vIndex = getViewIndexAtPosition(testPos);
if ((vIndex != -1) && (vIndex < getViewCount())) {
View v = getView(vIndex);
if (v != null && testPos >= v.getStartOffset() && testPos < v.getEndOffset()) {
Shape childShape = getChildAllocation(vIndex, a);
if (childShape == null) {
// We are likely invalid, fail.
return null;
}
Shape retShape = v.modelToView(pos, childShape, b);
if (retShape == null && v.getEndOffset() == pos) {
if (++vIndex < getViewCount()) {
v = getView(vIndex);
retShape = v.modelToView(pos, getChildAllocation(vIndex, a), b);
}
}
return retShape;
}
}
throw new BadLocationException("Position not represented by view", pos);
}
XTextFieldPeer(TextField target) {
super(target);
text = target.getText();
xtext = new XAWTTextField(text, this, target.getParent());
xtext.getDocument().addDocumentListener(xtext);
xtext.setCursor(target.getCursor());
XToolkit.specialPeerMap.put(xtext, this);
initTextField();
setText(target.getText());
if (target.echoCharIsSet()) {
setEchoChar(target.getEchoChar());
} else setEchoChar((char) 0);
int start = target.getSelectionStart();
int end = target.getSelectionEnd();
// Fix for 5100200
// Restoring Motif behaviour
// Since the end position of the selected text can be greater than the length of the text,
// so we should set caret to max position of the text
setCaretPosition(Math.min(end, text.length()));
if (end > start) {
// Should be called after setText() and setCaretPosition()
select(start, end);
}
setEditable(target.isEditable());
// After this line we should not change the component's text
firstChangeSkipped = true;
AWTAccessor.getComponentAccessor().setPeer(xtext, this);
}
/**
* 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.
}
@Override
public void remove(int offs, int len) throws BadLocationException {
int start = offs;
int end = offs + len;
int markStart = mark;
int markEnd = getLength();
if ((end < markStart) || (start > markEnd)) {
// no overlap
return;
}
// Determine interval intersection
int cutStart = Math.max(start, markStart);
int cutEnd = Math.min(end, markEnd);
super.remove(cutStart, cutEnd - cutStart);
}
public void start() {
Dimension size = getSize();
for (int i = 0; i < animpts.length; i += 2) {
animpts[i + 0] = (float) (Math.random() * size.width);
animpts[i + 1] = (float) (Math.random() * size.height);
deltas[i + 0] = (float) (Math.random() * 4.0 + 2.0);
deltas[i + 1] = (float) (Math.random() * 4.0 + 2.0);
if (animpts[i + 0] > size.width / 6.0f) {
deltas[i + 0] = -deltas[i + 0];
}
if (animpts[i + 1] > size.height / 6.0f) {
deltas[i + 1] = -deltas[i + 1];
}
}
anim = new Thread(this);
anim.setPriority(Thread.MIN_PRIORITY);
anim.start();
}
protected void updateByOpTree(javax.swing.text.DocumentFilter.FilterBypass fb) {
String oldStr = JMathTextField.this.getText();
String newStr = operatorTree.toString();
int commonStart = Utils.equalStartLen(oldStr, newStr);
int commonEnd = Utils.equalEndLen(oldStr, newStr);
if (commonEnd + commonStart >= Math.min(oldStr.length(), newStr.length()))
commonEnd = Math.min(oldStr.length(), newStr.length()) - commonStart;
try {
fb.replace(
commonStart,
oldStr.length() - commonEnd - commonStart,
newStr.substring(commonStart, newStr.length() - commonEnd),
null);
} catch (BadLocationException e) {
// this should not happen. we should have checked this. this whole function should be safe
throw new AssertionError(e);
}
}
/**
* Provides a mapping from the document model coordinate space to the coordinate space of the
* view mapped to it.
*
* @param pos the position to convert
* @param a the allocated region to render into
* @return the bounding box of the given position is returned
* @exception BadLocationException if the given position does not represent a valid location in
* the associated document.
*/
@Override
public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
// System.err.println("--- begin modelToView ---");
Rectangle alloc = a.getBounds();
RSyntaxTextArea textArea = (RSyntaxTextArea) getContainer();
alloc.height = textArea.getLineHeight(); // metrics.getHeight();
alloc.width = 1;
int p0 = getStartOffset();
int p1 = getEndOffset();
int testP = (b == Position.Bias.Forward) ? pos : Math.max(p0, pos - 1);
// Get the token list for this line so we don't have to keep
// recomputing it if this logical line spans multiple physical
// lines.
RSyntaxDocument doc = (RSyntaxDocument) getDocument();
Element map = doc.getDefaultRootElement();
int line = map.getElementIndex(p0);
Token tokenList = doc.getTokenListForLine(line);
float x0 = alloc.x; // 0;
while (p0 < p1) {
TokenSubList subList =
TokenUtils.getSubTokenList(
tokenList, p0, WrappedSyntaxView.this, textArea, x0, lineCountTempToken);
x0 = subList != null ? subList.x : x0;
tokenList = subList != null ? subList.tokenList : null;
int p = calculateBreakPosition(p0, tokenList, x0);
if ((pos >= p0) && (testP < p)) { // pos < p)) {
// it's in this line
alloc =
RSyntaxUtilities.getLineWidthUpTo(
textArea, s, p0, pos, WrappedSyntaxView.this, alloc, alloc.x);
// System.err.println("--- end modelToView ---");
return alloc;
}
// if (p == p1 && pos == p1) {
if (p == p1 - 1 && pos == p1 - 1) {
// Wants end.
if (pos > p0) {
alloc =
RSyntaxUtilities.getLineWidthUpTo(
textArea, s, p0, pos, WrappedSyntaxView.this, alloc, alloc.x);
}
// System.err.println("--- end modelToView ---");
return alloc;
}
p0 = (p == p0) ? p1 : p;
// System.err.println("... ... Incrementing y");
alloc.y += alloc.height;
}
throw new BadLocationException(null, pos);
}
public int getWidth() {
float fWidth;
int width;
fWidth = scale * nativeGetMaxWidth();
width = Math.round(fWidth);
if (parentContainer == null) {
return width;
} else {
return FTAUtilities.max(width, parentContainer.getWidth());
}
}
public int getHeight() {
float fHeight;
int height;
fHeight = scale * nativeGetMaxDepth();
height = Math.round(fHeight) + (2 * margin);
if (parentContainer == null) {
return height;
} else {
return FTAUtilities.max(height, parentContainer.getHeight());
}
}
/** 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);
}
}
/** 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;
}