/**
* Stores the position and size of the bouncing box that would be painted for the current
* animation index in <code>r</code> and returns <code>r</code>. Subclasses that add to the
* painting performed in this class's implementation of <code>paintIndeterminate</code> -- to draw
* an outline around the bouncing box, for example -- can use this method to get the location of
* the bouncing box that was just painted. By overriding this method, you have complete control
* over the size and position of the bouncing box, without having to reimplement <code>
* paintIndeterminate</code>.
*
* @param r the Rectangle instance to be modified; may be <code>null</code>
* @return <code>null</code> if no box should be drawn; otherwise, returns the passed-in rectangle
* (if non-null) or a new rectangle
* @see #setAnimationIndex
* @since 1.4
*/
protected Rectangle getBox(Rectangle r) {
int currentFrame = getAnimationIndex();
int middleFrame = numFrames / 2;
if (sizeChanged() || delta == 0.0 || maxPosition == 0.0) {
updateSizes();
}
r = getGenericBox(r);
if (r == null) {
return null;
}
if (middleFrame <= 0) {
return null;
}
// assert currentFrame >= 0 && currentFrame < numFrames
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
if (currentFrame < middleFrame) {
r.x = componentInnards.x + (int) Math.round(delta * (double) currentFrame);
} else {
r.x = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame));
}
} else { // VERTICAL indeterminate progress bar
if (currentFrame < middleFrame) {
r.y = componentInnards.y + (int) Math.round(delta * currentFrame);
} else {
r.y = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame));
}
}
return r;
}
public TaskbarPositionTest() {
super("Use CTRL-down to show a JPopupMenu");
setContentPane(panel = createContentPane());
setJMenuBar(createMenuBar("1 - First Menu", true));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// CTRL-down will show the popup.
panel
.getInputMap()
.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.CTRL_MASK), "OPEN_POPUP");
panel.getActionMap().put("OPEN_POPUP", new PopupHandler());
pack();
Toolkit toolkit = Toolkit.getDefaultToolkit();
fullScreenBounds = new Rectangle(new Point(), toolkit.getScreenSize());
screenBounds = new Rectangle(new Point(), toolkit.getScreenSize());
// Place the frame near the bottom. This is a pretty wild guess.
this.setLocation(0, (int) screenBounds.getHeight() - 2 * this.getHeight());
// Reduce the screen bounds by the insets.
GraphicsConfiguration gc = this.getGraphicsConfiguration();
if (gc != null) {
Insets screenInsets = toolkit.getScreenInsets(gc);
screenBounds = gc.getBounds();
screenBounds.width -= (screenInsets.left + screenInsets.right);
screenBounds.height -= (screenInsets.top + screenInsets.bottom);
screenBounds.x += screenInsets.left;
screenBounds.y += screenInsets.top;
}
setVisible(true);
}
// ------------------------------
public void
scrollToCaret() { // not called - fixed with putting visible scrollbars on JScrollPane
//
Rectangle rect1 = scroller1.getViewport().getViewRect();
double x1 = rect1.getX();
double y1 = rect1.getY();
double r1height = rect1.getHeight();
double r1width = rect1.getWidth();
Caret caret1 = editor1.getCaret();
Point pt2 = caret1.getMagicCaretPosition(); // the end of the string
double x2 = pt2.getX();
double y2 = pt2.getY();
if (((x2 > x1) && (x2 < (x1 + r1width))) && ((y2 > y1) && (y2 < (y1 + r1height)))) {
// inview
} else {
double newheight = r1height / 2;
double newwidth = r1width / 2;
double x3 = pt2.getX() - newwidth;
double y3 = pt2.getY() - newheight;
if (x3 < 0) x3 = 0;
if (y3 < 0) y3 = 0;
Rectangle rect3 = new Rectangle((int) x3, (int) y3, (int) newwidth, (int) newheight);
editor1.scrollRectToVisible(rect3);
}
} // end scrollToCaret
/**
* Provides a mapping, for a given region, from the document model coordinate space to the view
* coordinate space. The specified region is created as a union of the first and last character
* positions.
*
* @param p0 the position of the first character (>=0)
* @param b0 the bias of the first character position, toward the previous character or the next
* character represented by the offset, in case the position is a boundary of two views;
* <code>b0</code> will have one of these values:
* <ul>
* <li><code>Position.Bias.Forward</code>
* <li><code>Position.Bias.Backward</code>
* </ul>
*
* @param p1 the position of the last character (>=0)
* @param b1 the bias for the second character position, defined one of the legal values shown
* above
* @param a the area of the view, which encompasses the requested region
* @return the bounding box which is a union of the region specified by the first and last
* character positions
* @exception BadLocationException if the given position does not represent a valid location in
* the associated document
* @exception IllegalArgumentException if <code>b0</code> or <code>b1</code> are not one of the
* legal <code>Position.Bias</code> values listed above
* @see View#viewToModel
*/
public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a)
throws BadLocationException {
Shape s0 = modelToView(p0, a, b0);
Shape s1;
if (p1 == getEndOffset()) {
try {
s1 = modelToView(p1, a, b1);
} catch (BadLocationException ble) {
s1 = null;
}
if (s1 == null) {
// Assume extends left to right.
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();
s1 = new Rectangle(alloc.x + alloc.width - 1, alloc.y, 1, alloc.height);
}
} else {
s1 = modelToView(p1, a, b1);
}
Rectangle r0 = s0.getBounds();
Rectangle r1 = (s1 instanceof Rectangle) ? (Rectangle) s1 : s1.getBounds();
if (r0.y != r1.y) {
// If it spans lines, force it to be the width of the view.
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();
r0.x = alloc.x;
r0.width = alloc.width;
}
r0.add(r1);
return r0;
}
public void scrollToAttribute(Attribute a) {
if (!a.getDescriptor().getConfig().equals(getConfig())) {
logger.fine("Cannot scroll to attribute that isn't attached to this type of descriptor");
return;
}
int rowIndex = getCurrentModel().getRowForDescriptor(a.getDescriptor());
int colIndex = getCurrentModel().getColumnForAttribute(a);
JScrollPane scrollPane = (JScrollPane) this.getComponent(0);
JViewport viewport = (JViewport) scrollPane.getViewport();
EnhancedTable table = (EnhancedTable) viewport.getView();
// This rectangle is relative to the table where the
// northwest corner of cell (0,0) is always (0,0).
Rectangle rect = table.getCellRect(rowIndex, colIndex, true);
// The location of the viewport relative to the table
Point pt = viewport.getViewPosition();
// Translate the cell location so that it is relative
// to the view, assuming the northwest corner of the
// view is (0,0)
rect.setLocation(rect.x - pt.x, rect.y - pt.y);
// Scroll the area into view
viewport.scrollRectToVisible(rect);
}
private void ensureRowIsVisible(int nRow) {
Rectangle visibleRect = table.getCellRect(nRow, 0, true);
if (debugSetPath) System.out.println("----ensureRowIsVisible = " + visibleRect);
if (visibleRect != null) {
visibleRect.x = scrollPane.getViewport().getViewPosition().x;
table.scrollRectToVisible(visibleRect);
table.repaint();
}
}
private boolean sizeChanged() {
if ((oldComponentInnards == null) || (componentInnards == null)) {
return true;
}
oldComponentInnards.setRect(componentInnards);
componentInnards = SwingUtilities.calculateInnerArea(progressBar, componentInnards);
return !oldComponentInnards.equals(componentInnards);
}
/**
* Repaint the given line range.
*
* @param line0 The starting line number to repaint. This must be a valid line number in the
* model.
* @param line1 The ending line number to repaint. This must be a valid line number in the model.
* @param a The region allocated for the view to render into.
* @param host The component hosting the view (used to call repaint).
*/
protected void damageLineRange(int line0, int line1, Shape a, Component host) {
if (a != null) {
Rectangle area0 = lineToRect(a, line0);
Rectangle area1 = lineToRect(a, line1);
if ((area0 != null) && (area1 != null)) {
Rectangle dmg = area0.union(area1); // damage.
host.repaint(dmg.x, dmg.y, dmg.width, dmg.height);
} else host.repaint();
}
}
/**
* 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);
}
/**
* Sets the allocation rectangle for a given line's view, but sets the y value to the passed-in
* value. This should be used instead of {@link #childAllocation(int, Rectangle)} since it allows
* you to account for hidden lines in collapsed fold regions.
*
* @param line
* @param y
* @param alloc
*/
private void childAllocation2(int line, int y, Rectangle alloc) {
alloc.x += getOffset(X_AXIS, line);
alloc.y += y;
alloc.width = getSpan(X_AXIS, line);
alloc.height = getSpan(Y_AXIS, line);
// FIXME: This is required due to a bug that I can't track down. The
// top margin is being added twice somewhere in wrapped views, so we
// have to adjust for it here.
alloc.y -= host.getMargin().top;
}
/**
* Returns the tooltip text at the specified location. The default implementation returns the
* value from the child View identified by the passed in location.
*
* @since 1.4
* @see JTextComponent#getToolTipText
*/
public String getToolTipText(float x, float y, Shape allocation) {
int viewIndex = getViewIndex(x, y, allocation);
if (viewIndex >= 0) {
allocation = getChildAllocation(viewIndex, allocation);
Rectangle rect =
(allocation instanceof Rectangle) ? (Rectangle) allocation : allocation.getBounds();
if (rect.contains(x, y)) {
return getView(viewIndex).getToolTipText(x, y, allocation);
}
}
return null;
}
/**
* Returns an point which has been adjusted to take into account of the desktop bounds, taskbar
* and multi-monitor configuration.
*
* <p>This adustment may be cancelled by invoking the application with
* -Djavax.swing.adjustPopupLocationToFit=false
*/
Point adjustPopupLocationToFitScreen(int xPosition, int yPosition) {
Point popupLocation = new Point(xPosition, yPosition);
if (popupPostionFixDisabled == true || GraphicsEnvironment.isHeadless()) {
return popupLocation;
}
// Get screen bounds
Rectangle scrBounds;
GraphicsConfiguration gc = getCurrentGraphicsConfiguration(popupLocation);
Toolkit toolkit = Toolkit.getDefaultToolkit();
if (gc != null) {
// If we have GraphicsConfiguration use it to get screen bounds
scrBounds = gc.getBounds();
} else {
// If we don't have GraphicsConfiguration use primary screen
scrBounds = new Rectangle(toolkit.getScreenSize());
}
// Calculate the screen size that popup should fit
Dimension popupSize = JPopupMenu.this.getPreferredSize();
long popupRightX = (long) popupLocation.x + (long) popupSize.width;
long popupBottomY = (long) popupLocation.y + (long) popupSize.height;
int scrWidth = scrBounds.width;
int scrHeight = scrBounds.height;
if (!canPopupOverlapTaskBar()) {
// Insets include the task bar. Take them into account.
Insets scrInsets = toolkit.getScreenInsets(gc);
scrBounds.x += scrInsets.left;
scrBounds.y += scrInsets.top;
scrWidth -= scrInsets.left + scrInsets.right;
scrHeight -= scrInsets.top + scrInsets.bottom;
}
int scrRightX = scrBounds.x + scrWidth;
int scrBottomY = scrBounds.y + scrHeight;
// Ensure that popup menu fits the screen
if (popupRightX > (long) scrRightX) {
popupLocation.x = scrRightX - popupSize.width;
if (popupLocation.x < scrBounds.x) {
popupLocation.x = scrBounds.x;
}
}
if (popupBottomY > (long) scrBottomY) {
popupLocation.y = scrBottomY - popupSize.height;
if (popupLocation.y < scrBounds.y) {
popupLocation.y = scrBounds.y;
}
}
return popupLocation;
}
/** [Internal] */
public void paintComponent(Graphics g) {
boolean opq = true;
if (theOpaque != null) opq = theOpaque;
super.setOpaque(opq);
// if(theBackground!=null)super.setBackground(theBackground);
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
Rectangle rt = getBounds();
rt.x = 0;
rt.y = 0;
doBuffer(g2, opq, rt);
chkFPS();
}
/**
* 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
* @exception BadLocationException if the given position does not represent a valid location in
* the associated document
* @see View#modelToView
*/
public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
int p0 = getStartOffset();
int p1 = getEndOffset();
if ((pos >= p0) && (pos <= p1)) {
Rectangle r = a.getBounds();
if (pos == p1) {
r.x += r.width;
}
r.width = 0;
return r;
}
return null;
}
/**
* Sets the index of the current animation frame to the specified value and requests that the
* progress bar be repainted. Subclasses that don't use the default painting code might need to
* override this method to change the way that the <code>repaint</code> method is invoked.
*
* @param newValue the new animation index; no checking is performed on its value
* @see #incrementAnimationIndex
* @since 1.4
*/
protected void setAnimationIndex(int newValue) {
if (animationIndex != newValue) {
if (sizeChanged()) {
animationIndex = newValue;
maxPosition = 0; // needs to be recalculated
delta = 0.0; // needs to be recalculated
progressBar.repaint();
return;
}
// Get the previous box drawn.
nextPaintRect = getBox(nextPaintRect);
// Update the frame number.
animationIndex = newValue;
// Get the next box to draw.
if (nextPaintRect != null) {
boxRect = getBox(boxRect);
if (boxRect != null) {
nextPaintRect.add(boxRect);
}
}
} else { // animationIndex == newValue
return;
}
if (nextPaintRect != null) {
progressBar.repaint(nextPaintRect);
} else {
progressBar.repaint();
}
}
/**
* Returns the child view index representing the given position in the view. This iterates over
* all the children returning the first with a bounds that contains <code>x</code>, <code>y</code>
* .
*
* @param x the x coordinate
* @param y the y coordinate
* @param allocation current allocation of the View.
* @return index of the view representing the given location, or -1 if no view represents that
* position
* @since 1.4
*/
public int getViewIndex(float x, float y, Shape allocation) {
for (int counter = getViewCount() - 1; counter >= 0; counter--) {
Shape childAllocation = getChildAllocation(counter, allocation);
if (childAllocation != null) {
Rectangle rect =
(childAllocation instanceof Rectangle)
? (Rectangle) childAllocation
: allocation.getBounds();
if (rect.contains(x, y)) {
return counter;
}
}
}
return -1;
}
public void paint(Graphics g, JComponent c) {
if (grid.getRowCount() <= 0 || grid.getColumnCount() <= 0) {
return; // nothing to paint
}
Rectangle clip = g.getClipBounds();
Point minLocation = clip.getLocation();
Point maxLocation = new Point(clip.x + clip.width - 1, clip.y + clip.height - 1);
int rowMin = grid.rowAtPoint(minLocation);
int rowMax = grid.rowAtPoint(maxLocation);
// This should never happen.
if (rowMin == -1) {
rowMin = 0;
}
// If the spread does not have enough rows to fill the view we'll get -1.
// Replace this with the index of the last row.
if (rowMax == -1) {
rowMax = grid.getRowCount() - 1;
}
int colMin = grid.columnAtPoint(minLocation);
int colMax = grid.columnAtPoint(maxLocation);
// This should never happen.
if (colMin == -1) {
colMin = 0;
}
// If the spread does not have enough columns to fill the view we'll get -1.
// Replace this with the index of the last column.
if (colMax == -1) {
colMax = grid.getColumnCount() - 1;
}
// Paint cells
paintCells(g, rowMin, rowMax, colMin, colMax);
// Paint grid
paintGrid(g, rowMin, rowMax, colMin, colMax);
// Paint spans
paintSpans(g, rowMin, rowMax, colMin, colMax);
// Paint borders
paintBorders(g, rowMin, rowMax, colMin, colMax);
// Paint editor
paintEditor(g);
}
/**
* Provides a mapping, for a given region, from the document model coordinate space to the view
* coordinate space. The specified region is created as a union of the first and last character
* positions.
*
* <p>This is implemented to subtract the width of the second character, as this view's <code>
* modelToView</code> actually returns the width of the character instead of "1" or "0" like the
* View implementations in <code>javax.swing.text</code>. Thus, if we don't override this method,
* the <code>View</code> implementation will return one character's width too much for its
* consumers (implementations of <code>javax.swing.text.Highlighter</code>).
*
* @param p0 the position of the first character (>=0)
* @param b0 The bias of the first character position, toward the previous character or the next
* character represented by the offset, in case the position is a boundary of two views;
* <code>b0</code> will have one of these values:
* <ul>
* <li><code>Position.Bias.Forward</code>
* <li><code>Position.Bias.Backward</code>
* </ul>
*
* @param p1 the position of the last character (>=0)
* @param b1 the bias for the second character position, defined one of the legal values shown
* above
* @param a the area of the view, which encompasses the requested region
* @return the bounding box which is a union of the region specified by the first and last
* character positions
* @exception BadLocationException if the given position does not represent a valid location in
* the associated document
* @exception IllegalArgumentException if <code>b0</code> or <code>b1</code> are not one of the
* legal <code>Position.Bias</code> values listed above
* @see View#viewToModel
*/
@Override
public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a)
throws BadLocationException {
Shape s0 = modelToView(p0, a, b0);
Shape s1;
if (p1 == getEndOffset()) {
try {
s1 = modelToView(p1, a, b1);
} catch (BadLocationException ble) {
s1 = null;
}
if (s1 == null) {
// Assume extends left to right.
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();
s1 = new Rectangle(alloc.x + alloc.width - 1, alloc.y, 1, alloc.height);
}
} else {
s1 = modelToView(p1, a, b1);
}
Rectangle r0 = s0 instanceof Rectangle ? (Rectangle) s0 : s0.getBounds();
Rectangle r1 = s1 instanceof Rectangle ? (Rectangle) s1 : s1.getBounds();
if (r0.y != r1.y) {
// If it spans lines, force it to be the width of the view.
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle) a : a.getBounds();
r0.x = alloc.x;
r0.width = alloc.width;
}
r0.add(r1);
// The next line is the only difference between this method and
// View's implementation. We're subtracting the width of the second
// character. This is because this method is used by Highlighter
// implementations to get the area to "highlight", and if we don't do
// this, one character too many is highlighted thanks to our
// modelToView() implementation returning the actual width of the
// character requested!
if (p1 > p0) {
r0.width -= r1.width;
}
return r0;
}
private void paintBorder(Graphics g, Rectangle cellRect, int row, int column) {
if (grid.getSpanModel().isCellSpan(row, column)) {
CellSpan span = grid.getSpanModel().getSpanOver(row, column);
row = span.getRow();
column = span.getColumn();
}
// Paint border
javax.swing.border.Border border = grid.getStyleModel().getCellStyle(row, column).getBorder();
Insets borderInsets = border.getBorderInsets(grid);
Rectangle borderRect = new Rectangle(cellRect);
int topOffset = (borderInsets.top >> 1);
int leftOffset = (borderInsets.left >> 1);
int bottomOffset = (borderInsets.bottom / 3) + topOffset;
int rightOffset = (borderInsets.right / 3) + leftOffset;
borderRect.x -= leftOffset;
borderRect.y -= topOffset;
borderRect.width += rightOffset;
borderRect.height += bottomOffset;
border.paintBorder(grid, g, borderRect.x, borderRect.y, borderRect.width, borderRect.height);
}
/**
* 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);
}
}
}
}
/** Assumes that the component innards, max position, etc. are up-to-date. */
private Rectangle getGenericBox(Rectangle r) {
if (r == null) {
r = new Rectangle();
}
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
r.width = getBoxLength(componentInnards.width, componentInnards.height);
if (r.width < 0) {
r = null;
} else {
r.height = componentInnards.height;
r.y = componentInnards.y;
}
// end of HORIZONTAL
} else { // VERTICAL progress bar
r.height = getBoxLength(componentInnards.height, componentInnards.width);
if (r.height < 0) {
r = null;
} else {
r.width = componentInnards.width;
r.x = componentInnards.x;
}
} // end of VERTICAL
return r;
}
@Override
public boolean isCellEditable(EventObject e) {
if (e instanceof MouseEvent && e.getSource() instanceof JTree) {
MouseEvent me = (MouseEvent) e;
JTree tree = (JTree) e.getSource();
TreePath path = tree.getPathForLocation(me.getX(), me.getY());
Rectangle r = tree.getPathBounds(path);
if (r == null) {
return false;
}
Dimension d = getPreferredSize();
r.setSize(new Dimension(d.width, r.height));
if (r.contains(me.getX(), me.getY())) {
if (str == null && System.getProperty("java.version").startsWith("1.7.0")) {
setBounds(new Rectangle(0, 0, d.width, r.height));
}
// System.out.println(getBounds());
return true;
}
}
return false;
}
public void actionPerformed(ActionEvent e) {
JGrid grid = (JGrid) e.getSource();
if (toLimit) {
if (vertically) {
int rowCount = grid.getRowCount();
this.dx = 0;
this.dy = forwards ? rowCount : -rowCount;
} else {
int colCount = grid.getColumnCount();
this.dx = forwards ? colCount : -colCount;
this.dy = 0;
}
} else {
if (!(grid.getParent().getParent() instanceof JScrollPane)) {
return;
}
Dimension delta = grid.getParent().getSize();
SelectionModel sm = grid.getSelectionModel();
int start = 0;
if (vertically) {
start = (extend) ? sm.getLeadRow() : sm.getAnchorRow();
} else {
start = (extend) ? sm.getLeadColumn() : sm.getAnchorColumn();
}
if (vertically) {
Rectangle r = grid.getCellBounds(start, 0);
r.y += forwards ? delta.height : -delta.height;
this.dx = 0;
int newRow = grid.rowAtPoint(r.getLocation());
if (newRow == -1 && forwards) {
newRow = grid.getRowCount();
}
this.dy = newRow - start;
} else {
Rectangle r = grid.getCellBounds(0, start);
r.x += forwards ? delta.width : -delta.width;
int newColumn = grid.columnAtPoint(r.getLocation());
if (newColumn == -1 && forwards) {
newColumn = grid.getColumnCount();
}
this.dx = newColumn - start;
this.dy = 0;
}
}
super.actionPerformed(e);
}
private void adjust(
Rectangle bounds, Dimension min, int deltaX, int deltaY, int deltaWidth, int deltaHeight) {
bounds.x += deltaX;
bounds.y += deltaY;
bounds.width += deltaWidth;
bounds.height += deltaHeight;
if (min != null) {
if (bounds.width < min.width) {
int correction = min.width - bounds.width;
if (deltaX != 0) {
bounds.x -= correction;
}
bounds.width = min.width;
}
if (bounds.height < min.height) {
int correction = min.height - bounds.height;
if (deltaY != 0) {
bounds.y -= correction;
}
bounds.height = min.height;
}
}
}
/**
* 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();
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)) {
View view = getView(i);
drawView(g2d, alloc, view, fontHeight, tempRect.y + ascent);
}
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);
}
}
}
}
public void mouseDragged(MouseEvent ev) {
Window w = (Window) ev.getSource();
Point pt = ev.getPoint();
if (isMovingWindow) {
Point windowPt;
try {
windowPt = (Point) AccessController.doPrivileged(getLocationAction);
windowPt.x = windowPt.x - dragOffsetX;
windowPt.y = windowPt.y - dragOffsetY;
w.setLocation(windowPt);
} catch (PrivilegedActionException e) {
}
} else if (dragCursor != 0) {
Rectangle r = w.getBounds();
Rectangle startBounds = new Rectangle(r);
Dimension min = w.getMinimumSize();
switch (dragCursor) {
case Cursor.E_RESIZE_CURSOR:
adjust(r, min, 0, 0, pt.x + (dragWidth - dragOffsetX) - r.width, 0);
break;
case Cursor.S_RESIZE_CURSOR:
adjust(r, min, 0, 0, 0, pt.y + (dragHeight - dragOffsetY) - r.height);
break;
case Cursor.N_RESIZE_CURSOR:
adjust(r, min, 0, pt.y - dragOffsetY, 0, -(pt.y - dragOffsetY));
break;
case Cursor.W_RESIZE_CURSOR:
adjust(r, min, pt.x - dragOffsetX, 0, -(pt.x - dragOffsetX), 0);
break;
case Cursor.NE_RESIZE_CURSOR:
adjust(
r,
min,
0,
pt.y - dragOffsetY,
pt.x + (dragWidth - dragOffsetX) - r.width,
-(pt.y - dragOffsetY));
break;
case Cursor.SE_RESIZE_CURSOR:
adjust(
r,
min,
0,
0,
pt.x + (dragWidth - dragOffsetX) - r.width,
pt.y + (dragHeight - dragOffsetY) - r.height);
break;
case Cursor.NW_RESIZE_CURSOR:
adjust(
r,
min,
pt.x - dragOffsetX,
pt.y - dragOffsetY,
-(pt.x - dragOffsetX),
-(pt.y - dragOffsetY));
break;
case Cursor.SW_RESIZE_CURSOR:
adjust(
r,
min,
pt.x - dragOffsetX,
0,
-(pt.x - dragOffsetX),
pt.y + (dragHeight - dragOffsetY) - r.height);
break;
default:
break;
}
if (!r.equals(startBounds)) {
w.setBounds(r);
// Defer repaint/validate on mouseReleased unless dynamic
// layout is active.
if (Toolkit.getDefaultToolkit().isDynamicLayoutActive()) {
w.validate();
getRootPane().repaint();
}
}
}
}
/**
* Provides a mapping from the document model coordinate space to the coordinate space of the view
* mapped to it.
*
* @param p0 the position to convert >= 0
* @param b0 the bias toward the previous character or the next character represented by p0, in
* case the position is a boundary of two views; either <code>Position.Bias.Forward</code> or
* <code>Position.Bias.Backward</code>
* @param p1 the position to convert >= 0
* @param b1 the bias toward the previous character or the next character represented by p1, in
* case the position is a boundary of two views
* @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
* @exception IllegalArgumentException for an invalid bias argument
* @see View#viewToModel
*/
public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a)
throws BadLocationException {
if (p0 == getStartOffset() && p1 == getEndOffset()) {
return a;
}
Rectangle alloc = getInsideAllocation(a);
Rectangle r0 = new Rectangle(alloc);
View v0 = getViewAtPosition((b0 == Position.Bias.Backward) ? Math.max(0, p0 - 1) : p0, r0);
Rectangle r1 = new Rectangle(alloc);
View v1 = getViewAtPosition((b1 == Position.Bias.Backward) ? Math.max(0, p1 - 1) : p1, r1);
if (v0 == v1) {
if (v0 == null) {
return a;
}
// Range contained in one view
return v0.modelToView(p0, b0, p1, b1, r0);
}
// Straddles some views.
int viewCount = getViewCount();
int counter = 0;
while (counter < viewCount) {
View v;
// Views may not be in same order as model.
// v0 or v1 may be null if there is a gap in the range this
// view contains.
if ((v = getView(counter)) == v0 || v == v1) {
View endView;
Rectangle retRect;
Rectangle tempRect = new Rectangle();
if (v == v0) {
retRect =
v0.modelToView(p0, b0, v0.getEndOffset(), Position.Bias.Backward, r0).getBounds();
endView = v1;
} else {
retRect =
v1.modelToView(v1.getStartOffset(), Position.Bias.Forward, p1, b1, r1).getBounds();
endView = v0;
}
// Views entirely covered by range.
while (++counter < viewCount && (v = getView(counter)) != endView) {
tempRect.setBounds(alloc);
childAllocation(counter, tempRect);
retRect.add(tempRect);
}
// End view.
if (endView != null) {
Shape endShape;
if (endView == v1) {
endShape = v1.modelToView(v1.getStartOffset(), Position.Bias.Forward, p1, b1, r1);
} else {
endShape = v0.modelToView(p0, b0, v0.getEndOffset(), Position.Bias.Backward, r0);
}
if (endShape instanceof Rectangle) {
retRect.add((Rectangle) endShape);
} else {
retRect.add(endShape.getBounds());
}
}
return retRect;
}
counter++;
}
throw new BadLocationException("Position not represented by view", p0);
}
/**
* Provides a mapping from the view coordinate space to the logical coordinate space of the
* model.
*
* @param fx the X coordinate
* @param fy the Y coordinate
* @param a the allocated region to render into
* @return the location within the model that best represents the given point in the view
* @see View#viewToModel
*/
@Override
public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {
// PENDING(prinz) implement bias properly
bias[0] = Position.Bias.Forward;
Rectangle alloc = (Rectangle) a;
RSyntaxDocument doc = (RSyntaxDocument) getDocument();
int x = (int) fx;
int y = (int) fy;
if (y < alloc.y) {
// above the area covered by this icon, so the the position
// is assumed to be the start of the coverage for this view.
return getStartOffset();
} else if (y > alloc.y + alloc.height) {
// below the area covered by this icon, so the the position
// is assumed to be the end of the coverage for this view.
return getEndOffset() - 1;
} else {
// positioned 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.
RSyntaxTextArea textArea = (RSyntaxTextArea) getContainer();
alloc.height = textArea.getLineHeight();
int p1 = getEndOffset();
// Get the token list for this line so we don't have to keep
// recomputing it if this logical line spans multiple
// physical lines.
Element map = doc.getDefaultRootElement();
int p0 = getStartOffset();
int line = map.getElementIndex(p0);
Token tlist = doc.getTokenListForLine(line);
// Look at each physical line-chunk of this logical line.
while (p0 < p1) {
// We can always use alloc.x since we always break
// lines so they start at the beginning of a physical
// line.
TokenSubList subList =
TokenUtils.getSubTokenList(
tlist, p0, WrappedSyntaxView.this, textArea, alloc.x, lineCountTempToken);
tlist = subList != null ? subList.tokenList : null;
int p = calculateBreakPosition(p0, tlist, alloc.x);
// If desired view position is in this physical chunk.
if ((y >= alloc.y) && (y < (alloc.y + alloc.height))) {
// Point is to the left of the line
if (x < alloc.x) {
return p0;
}
// Point is to the right of the line
else if (x > alloc.x + alloc.width) {
return p - 1;
}
// Point is in this physical line!
else {
// Start at alloc.x since this chunk starts
// at the beginning of a physical line.
int n = tlist.getListOffset(textArea, WrappedSyntaxView.this, alloc.x, x);
// NOTE: We needed to add the max() with
// p0 as getTokenListForLine returns -1
// for empty lines (just a null token).
// How did this work before?
// FIXME: Have null tokens have their
// offset but a -1 length.
return Math.max(Math.min(n, p1 - 1), p0);
} // End of else.
} // End of if ((y>=alloc.y) && ...
p0 = (p == p0) ? p1 : p;
alloc.y += alloc.height;
} // End of while (p0<p1).
return getEndOffset() - 1;
} // End of else.
}
/**
* Sets the allocation rectangle for a given line's view, but sets the y value to the passed-in
* value. This should be used instead of {@link #childAllocation(int, Rectangle)} since it allows
* you to account for hidden lines in collapsed fold regions.
*
* @param line
* @param y
* @param alloc
*/
private void childAllocation2(int line, int y, Rectangle alloc) {
alloc.x += getOffset(X_AXIS, line);
alloc.y += y;
alloc.width = getSpan(X_AXIS, line);
alloc.height = getSpan(Y_AXIS, line);
}
/**
* Adjusts the allocation given to the view to be a suitable allocation for a text field. If the
* view has been allocated more than the preferred span vertically, the allocation is changed to
* be centered vertically. Horizontally the view is adjusted according to the horizontal alignment
* property set on the associated JTextField (if that is the type of the hosting component).
*
* @param a the allocation given to the view, which may need to be adjusted.
* @return the allocation that the superclass should use.
*/
protected Shape adjustAllocation(Shape a) {
if (a != null) {
Rectangle bounds = a.getBounds();
int vspan = (int) getPreferredSpan(Y_AXIS);
int hspan = (int) getPreferredSpan(X_AXIS);
if (bounds.height != vspan) {
int slop = bounds.height - vspan;
bounds.y += slop / 2;
bounds.height -= slop;
}
// horizontal adjustments
Component c = getContainer();
if (c instanceof JTextField) {
JTextField field = (JTextField) c;
BoundedRangeModel vis = field.getHorizontalVisibility();
int max = Math.max(hspan, bounds.width);
int value = vis.getValue();
int extent = Math.min(max, bounds.width - 1);
if ((value + extent) > max) {
value = max - extent;
}
vis.setRangeProperties(value, extent, vis.getMinimum(), max, false);
if (hspan < bounds.width) {
// horizontally align the interior
int slop = bounds.width - 1 - hspan;
int align = ((JTextField) c).getHorizontalAlignment();
if (Utilities.isLeftToRight(c)) {
if (align == LEADING) {
align = LEFT;
} else if (align == TRAILING) {
align = RIGHT;
}
} else {
if (align == LEADING) {
align = RIGHT;
} else if (align == TRAILING) {
align = LEFT;
}
}
switch (align) {
case SwingConstants.CENTER:
bounds.x += slop / 2;
bounds.width -= slop;
break;
case SwingConstants.RIGHT:
bounds.x += slop;
bounds.width -= slop;
break;
}
} else {
// adjust the allocation to match the bounded range.
bounds.width = hspan;
bounds.x -= vis.getValue();
}
}
return bounds;
}
return null;
}
