@Override public void paint(Graphics g) { Rectangle clipBounds = g.getClipBounds(); paintBackgroundAndFoldingLine(g, clipBounds); paintTextColumns(g, clipBounds); paintIconRenderers(g, clipBounds); paintFoldingArea(g, clipBounds); }
/** * Paint each <code>Lite</code> object in turn after testing if it is inside the clip of the * Graphics. This is the right way to do it if the repainting time of <code>Lite</code> objects is * much greater than the time required to compute its bounds. * * @see excentric.LiteGroup#paintAll(java.awt.Graphics) */ public void paint(Graphics g) { Rectangle clip = g.getClipBounds(); for (Enumeration e = lites.elements(); e.hasMoreElements(); ) { Lite l = (Lite) e.nextElement(); // if (l.getBounds().intersects(clip)) l.paint(g); } }
/** * This method will draw the axes. * * @param gc the graphics * @return the (clipped) graphics for the line */ Graphics paintAxis(Graphics gc) { int originx = 0; int originy = 0; Rectangle space = gc.getClipBounds(); int yTickLen = (int) (space.width * axispercent / 100.0); if (yTickLen < 2) { yTickLen = 2; } else if (yTickLen > 5) { yTickLen = 5; } int xTickLen = (int) (space.height * axispercent / 100.0); if (xTickLen < 2) { xTickLen = 2; } else if (xTickLen > 5) { xTickLen = 5; } originx = yTickLen; originy = space.height - xTickLen; // do the Y axis int tickoff = space.height / (numYTicks - 1); int x1 = 0; int x2 = originx; int y1 = originy; for (int tick = 0; tick < numYTicks; tick++) { gc.drawLine(x1, y1, x2, y1); y1 -= tickoff; } gc.drawLine(originx, originy, originx, y1 + tickoff); // do the X axis tickoff = space.width / (numXTicks - 1); x1 = originx; y1 = space.height; int y2 = originy; for (int tick = 0; tick < numXTicks; tick++) { gc.drawLine(x1, y1, x1, y2); x1 += tickoff; } // now draw the X axis gc.drawLine(originx, originy, space.width, originy); gc = gc.create(originx + 1, 0, space.width - originx - 1, originy); return gc; }
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); }
@Override protected void paintTrack(Graphics g, JComponent c, Rectangle bounds) { g.setColor(TRACK_BACKGROUND); g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height); g.setColor(TRACK_BORDER); int border = isMirrored() ? bounds.x + bounds.width - 1 : bounds.x; g.drawLine(border, bounds.y, border, bounds.y + bounds.height); ((ApplicationImpl) ApplicationManager.getApplication()).editorPaintStart(); try { Rectangle clipBounds = g.getClipBounds(); repaint(g, ERROR_ICON_WIDTH - 1, clipBounds); } finally { ((ApplicationImpl) ApplicationManager.getApplication()).editorPaintFinish(); } }
/** special paint handler for merged cell regions */ protected void paintSpans(Graphics g, int rowMin, int rowMax, int colMin, int colMax) { Rectangle clip = g.getClipBounds(); Iterator cell = grid.getSpanModel().getSpanIterator(); while (cell.hasNext()) { CellSpan span = (CellSpan) cell.next(); Rectangle cellBounds = grid.getCellBounds(span.getRow(), span.getColumn()); // Only paint cell if visible if (span.getLastRow() >= rowMin && span.getLastColumn() >= colMin && span.getFirstRow() <= rowMax && span.getFirstColumn() <= colMax) { paintCell(g, cellBounds, span.getRow(), span.getColumn()); // Paint grid line around cell if (grid.getShowGrid()) { g.setColor(grid.getGridColor()); g.drawRect(cellBounds.x, cellBounds.y, cellBounds.width, cellBounds.height); } } } }
@Override @SuppressWarnings({"AssignmentToForLoopParameter"}) public void paint( @NotNull Editor editor, @NotNull RangeHighlighter highlighter, @NotNull Graphics g) { int startOffset = highlighter.getStartOffset(); final Document doc = highlighter.getDocument(); if (startOffset >= doc.getTextLength()) return; final int endOffset = highlighter.getEndOffset(); final int endLine = doc.getLineNumber(endOffset); int off; int startLine = doc.getLineNumber(startOffset); IndentGuideDescriptor descriptor = editor.getIndentsModel().getDescriptor(startLine, endLine); final CharSequence chars = doc.getCharsSequence(); do { int start = doc.getLineStartOffset(startLine); int end = doc.getLineEndOffset(startLine); off = CharArrayUtil.shiftForward(chars, start, end, " \t"); startLine--; } while (startLine > 1 && off < doc.getTextLength() && chars.charAt(off) == '\n'); final VisualPosition startPosition = editor.offsetToVisualPosition(off); int indentColumn = startPosition.column; // It's considered that indent guide can cross not only white space but comments, javadocs // etc. Hence, there is a possible // case that the first indent guide line is, say, single-line comment where comment // symbols ('//') are located at the first // visual column. We need to calculate correct indent guide column then. int lineShift = 1; if (indentColumn <= 0 && descriptor != null) { indentColumn = descriptor.indentLevel; lineShift = 0; } if (indentColumn <= 0) return; final FoldingModel foldingModel = editor.getFoldingModel(); if (foldingModel.isOffsetCollapsed(off)) return; final FoldRegion headerRegion = foldingModel.getCollapsedRegionAtOffset(doc.getLineEndOffset(doc.getLineNumber(off))); final FoldRegion tailRegion = foldingModel.getCollapsedRegionAtOffset( doc.getLineStartOffset(doc.getLineNumber(endOffset))); if (tailRegion != null && tailRegion == headerRegion) return; final boolean selected; final IndentGuideDescriptor guide = editor.getIndentsModel().getCaretIndentGuide(); if (guide != null) { final CaretModel caretModel = editor.getCaretModel(); final int caretOffset = caretModel.getOffset(); selected = caretOffset >= off && caretOffset < endOffset && caretModel.getLogicalPosition().column == indentColumn; } else { selected = false; } Point start = editor.visualPositionToXY( new VisualPosition(startPosition.line + lineShift, indentColumn)); final VisualPosition endPosition = editor.offsetToVisualPosition(endOffset); Point end = editor.visualPositionToXY(new VisualPosition(endPosition.line, endPosition.column)); int maxY = end.y; if (endPosition.line == editor.offsetToVisualPosition(doc.getTextLength()).line) { maxY += editor.getLineHeight(); } Rectangle clip = g.getClipBounds(); if (clip != null) { if (clip.y >= maxY || clip.y + clip.height <= start.y) { return; } maxY = Math.min(maxY, clip.y + clip.height); } final EditorColorsScheme scheme = editor.getColorsScheme(); g.setColor( selected ? scheme.getColor(EditorColors.SELECTED_INDENT_GUIDE_COLOR) : scheme.getColor(EditorColors.INDENT_GUIDE_COLOR)); // There is a possible case that indent line intersects soft wrap-introduced text. // Example: // this is a long line <soft-wrap> // that| is soft-wrapped // | // | <- vertical indent // // Also it's possible that no additional intersections are added because of soft wrap: // this is a long line <soft-wrap> // | that is soft-wrapped // | // | <- vertical indent // We want to use the following approach then: // 1. Show only active indent if it crosses soft wrap-introduced text; // 2. Show indent as is if it doesn't intersect with soft wrap-introduced text; if (selected) { g.drawLine(start.x + 2, start.y, start.x + 2, maxY); } else { int y = start.y; int newY = start.y; SoftWrapModel softWrapModel = editor.getSoftWrapModel(); int lineHeight = editor.getLineHeight(); for (int i = Math.max(0, startLine + lineShift); i < endLine && newY < maxY; i++) { List<? extends SoftWrap> softWraps = softWrapModel.getSoftWrapsForLine(i); int logicalLineHeight = softWraps.size() * lineHeight; if (i > startLine + lineShift) { logicalLineHeight += lineHeight; // We assume that initial 'y' value points just below the target // line. } if (!softWraps.isEmpty() && softWraps.get(0).getIndentInColumns() < indentColumn) { if (y < newY || i > startLine + lineShift) { // There is a possible case that soft wrap is located on // indent start line. g.drawLine(start.x + 2, y, start.x + 2, newY + lineHeight); } newY += logicalLineHeight; y = newY; } else { newY += logicalLineHeight; } FoldRegion foldRegion = foldingModel.getCollapsedRegionAtOffset(doc.getLineEndOffset(i)); if (foldRegion != null && foldRegion.getEndOffset() < doc.getTextLength()) { i = doc.getLineNumber(foldRegion.getEndOffset()); } } if (y < maxY) { g.drawLine(start.x + 2, y, start.x + 2, maxY); } } }
/** * This method will draw the line. * * @param gc the graphics * @see #setLog */ void paintLine(Graphics g) { double dvalue; int[] values = dataSet.getValues(); // first decide the x scale factor; if ((dataSet == null) || (dataSet.getSize() < 1)) { return; // nothing to draw } // the maximum number of values we are every going to get int capacity = dataSet.getCapacity(); // the available number of values at the moment int nr = dataSet.getSize(); Rectangle space = g.getClipBounds(); // pixel width of x values int width = space.width; int xscale = (int) (width / capacity); if (xscale < 1) { xscale = 1; } width = xscale * capacity; if (width > space.width) { width = space.width; } // pixel width of y values float yscale = (space.height) / (float) (dmax - dmin); // offset into array int xstart = 0; if (width < (nr * xscale)) { // we are lacking space xstart = nr - (int) (width / xscale); } // if needed reallocate some space int totx = nr - xstart + 1; if (xline.length < totx) { xline = new int[totx + 100]; yline = new int[totx + 100]; } // now workout where to put the first point so that // the last one ends up on the right hand edge int x = width - (int) ((nr - xstart - 1) * xscale); if (x < 0) { x = 0; // can't be negative System.out.println("negative start point in graph."); } int y; int ox = x; x += xscale; dvalue = values[xstart]; if (doLog) { dvalue = log10(values[xstart]); } xstart++; int oy = space.height - (int) ((dvalue - dmin) * yscale); int pt = 0; for (int i = xstart; i < nr; i++) { dvalue = values[i]; if (doLog) { dvalue = log10(values[i]); } y = space.height - (int) ((dvalue - dmin) * yscale); xline[pt] = x; yline[pt] = y; pt++; ox = x; oy = y; x += xscale; } g.drawPolyline(xline, yline, pt); }