private static Icon getThemeIcon(ColorScheme colorScheme, boolean square) {
int iSize = SubstanceSizeUtils.getTitlePaneIconSize();
BufferedImage result = SubstanceCoreUtilities.getBlankImage(iSize, iSize);
Graphics2D graphics = (Graphics2D) result.getGraphics().create();
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Color color1 = (colorScheme == null) ? Color.red : colorScheme.getUltraDarkColor();
Color color2 = (colorScheme == null) ? Color.green : colorScheme.getMidColor();
Color color3 = (colorScheme == null) ? Color.blue : colorScheme.getExtraLightColor();
graphics.setColor(color1);
if (square) graphics.fillRect(5, 2, 6, 6);
else graphics.fillOval(5, 2, 6, 6);
graphics.setColor(color1.darker());
if (square) graphics.drawRect(5, 2, 6, 6);
else graphics.drawOval(5, 2, 6, 6);
graphics.setColor(color2);
if (square) graphics.fillRect(1, 9, 6, 6);
else graphics.fillOval(1, 9, 6, 6);
graphics.setColor(color2.darker());
if (square) graphics.drawRect(1, 9, 6, 6);
else graphics.drawOval(1, 9, 6, 6);
graphics.setColor(color3);
if (square) graphics.fillRect(9, 9, 6, 6);
else graphics.fillOval(9, 9, 6, 6);
graphics.setColor(color3.darker());
if (square) graphics.drawRect(9, 9, 6, 6);
else graphics.drawOval(9, 9, 6, 6);
graphics.dispose();
return new ImageIcon(result);
}
@Override
public void paint(Graphics g) {
super.paint(g);
if (g instanceof Graphics2D) {
Graphics2D g2d = (Graphics2D) g;
if (blackOutEnabled) {
// background
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
} else if (whiteOutEnabled) {
// background
g2d.setColor(Color.WHITE);
g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
} else {
// background
g2d.setColor(backgroundColor);
g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
// text
if (font == null)
font = GuiHelper.maxFontSize(frame.getWidth(), frame.getHeight(), fontName, timeFormat);
if (textY == -1) textY = GuiHelper.getTextYForCenter(timeFormat, font, frame.getHeight());
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2d.setFont(font);
g2d.setColor(textColor);
g2d.drawString(timeToString(time), 0, textY);
}
}
}
private void shadeExt(Graphics2D g2, int r, int g, int b, int a) {
g2.setPaint(new Color(r, g, b, a));
g2.fillRect(0, 0, iw, rect.y); /* _N_ */
g2.fillRect(
rect.x + rect.width + 1, rect.y, iw - rect.x - rect.width - 1, rect.height + 1); /* E */
g2.fillRect(0, rect.y, rect.x, rect.height + 1); /* W */
g2.fillRect(0, rect.y + rect.height + 1, iw, ih - rect.y - rect.height - 1); /* _S_ */
}
private void paintCaret(Graphics2D g_) {
EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(true);
if (locations == null) return;
Graphics2D g = IdeBackgroundUtil.getOriginalGraphics(g_);
int lineHeight = myView.getLineHeight();
EditorSettings settings = myEditor.getSettings();
Color caretColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_COLOR);
if (caretColor == null) caretColor = new JBColor(CARET_DARK, CARET_LIGHT);
g.setColor(caretColor);
for (EditorImpl.CaretRectangle location : locations) {
int x = location.myPoint.x;
int y = location.myPoint.y;
Caret caret = location.myCaret;
boolean isRtl = location.myIsRtl;
if (myEditor.isInsertMode() != settings.isBlockCursor()) {
int lineWidth = JBUI.scale(settings.getLineCursorWidth());
g.fillRect(x, y, lineWidth, lineHeight);
if (myDocument.getTextLength() > 0
&& caret != null
&& !myView.getLineLayout(caret.getLogicalPosition().line).isLtr()) {
g.fillPolygon(
new int[] {
isRtl ? x + lineWidth : x,
isRtl ? x + lineWidth - CARET_DIRECTION_MARK_SIZE : x + CARET_DIRECTION_MARK_SIZE,
isRtl ? x + lineWidth : x
},
new int[] {y, y, y + CARET_DIRECTION_MARK_SIZE},
3);
}
} else {
int width = location.myWidth;
int startX = Math.max(0, isRtl ? x - width : x);
g.fillRect(startX, y, width, lineHeight - 1);
if (myDocument.getTextLength() > 0 && caret != null) {
int targetVisualColumn = caret.getVisualPosition().column;
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, caret.getVisualLineStart(), false)) {
int startVisualColumn = fragment.getStartVisualColumn();
int endVisualColumn = fragment.getEndVisualColumn();
if (startVisualColumn < targetVisualColumn && endVisualColumn > targetVisualColumn
|| startVisualColumn == targetVisualColumn && !isRtl
|| endVisualColumn == targetVisualColumn && isRtl) {
g.setColor(ColorUtil.isDark(caretColor) ? CARET_LIGHT : CARET_DARK);
fragment.draw(
g,
startX,
y + myView.getAscent(),
targetVisualColumn - startVisualColumn - (isRtl ? 1 : 0),
targetVisualColumn - startVisualColumn + (isRtl ? 0 : 1));
break;
}
}
}
}
}
}
public static ImageIcon generateIcon(Color _color) {
int size = (int) (16 * scaleFactor);
BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics = (Graphics2D) image.getGraphics();
graphics.setColor(Color.BLACK);
graphics.fillRect(0, 0, size, size);
graphics.setColor(_color);
graphics.fillRect(1, 1, size - 2, size - 2);
return new ImageIcon(image);
}
// =========================================================== paintComponent
@Override
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g; // Downcast to Graphics2D
// ... One time initialization of in-memory, saved image.
if (_bufImage == null) {
// ... This is the first time, initialize _bufImage
int w = this.getWidth();
int h = this.getHeight();
_bufImage = (BufferedImage) this.createImage(w, h);
Graphics2D gc = _bufImage.createGraphics();
gc.setColor(COLOR_BACKGROUND);
gc.fillRect(0, 0, w, h); // fill in background
}
// ... Display the saved image.
g2.drawImage(_bufImage, null, 0, 0);
// ... Overwrite the screen display with currently dragged image.
if (_state == State.DRAGGING) {
// ... Write shape that is being dragged over the screen image,
// but not into the saved buffered image. It will be written
// on the saved image when the mouse is released.
drawCurrentShape(g2);
}
}
public void saveMapAs(
final File selectedFile, FileExporter exporter, MapTransformer<COORD> transformer)
throws IOException {
exporter.setup(selectedFile, transformer.getWidth(), transformer.getHeight());
final Graphics2D g2 = exporter.getG2();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(MapPanel.BG_COLOR);
g2.fillRect(0, 0, transformer.getWidth(), transformer.getHeight());
Rectangle bbox = transformer.getGarminBoundingBox();
int minLon = bbox.x;
int maxLon = bbox.x + bbox.width;
int minLat = bbox.y;
int maxLat = bbox.y + bbox.height;
int resolution = getResolution(minLon, maxLon, transformer.getWidth());
TransformedMapListener drawer =
createMapDrawer(new MapConfig(), g2, exporter.getFontSize(), transformer);
MapListener listener =
new CoordinateConverterListener<COORD>(
transformer,
new ClippingMapListener(0, transformer.getWidth(), 0, transformer.getHeight(), drawer));
map.readMapForDrawing(minLon, maxLon, minLat, maxLat, resolution, ObjectKind.ALL, listener);
exporter.finishSave();
}
public void generarFondo(Component componente) {
boolean dibujarFondo = false;
Rectangle med = this.getBounds();
Rectangle areaDibujo = this.getBounds();
BufferedImage tmp;
GraphicsConfiguration gc =
GraphicsEnvironment.getLocalGraphicsEnvironment()
.getDefaultScreenDevice()
.getDefaultConfiguration();
if (Principal.fondoBlur) {
dibujarFondo = true;
}
if (dibujarFondo) {
JRootPane root = SwingUtilities.getRootPane(this);
blurBuffer = GraphicsUtilities.createCompatibleImage(Principal.sysAncho, Principal.sysAlto);
Graphics2D g2 = blurBuffer.createGraphics();
g2.setClip(med);
blurBuffer = blurBuffer.getSubimage(med.x, med.y, med.width, med.height);
((Escritorio) Principal.getEscritorio()).getFrameEscritorio().paint(g2);
g2.dispose();
backBuffer = blurBuffer;
// blurBuffer = toGrayScale(blurBuffer);
blurBuffer = GraphicsUtilities.createThumbnailFast(blurBuffer, getWidth() / 2);
blurBuffer = new GaussianBlurFilter(4).filter(blurBuffer, null);
g2 = (Graphics2D) blurBuffer.getGraphics();
g2.setColor(new Color(0, 0, 0, 195));
g2.fillRect(0, 0, Principal.sysAncho, Principal.sysAlto);
listo = true;
}
}
/**
* Gets (creates if necessary) disabled icon based on the passed one.
*
* @return <code>ImageIcon</code> constructed from disabled image of passed icon.
*/
@Nullable
public static Icon getDisabledIcon(Icon icon) {
if (icon instanceof LazyIcon) icon = ((LazyIcon) icon).getOrComputeIcon();
if (icon == null) return null;
Icon disabledIcon = ourIcon2DisabledIcon.get(icon);
if (disabledIcon == null) {
if (!isGoodSize(icon)) {
LOG.error(icon); // # 22481
return EMPTY_ICON;
}
final int scale = UIUtil.isRetina() ? 2 : 1;
@SuppressWarnings("UndesirableClassUsage")
BufferedImage image =
new BufferedImage(
scale * icon.getIconWidth(),
scale * icon.getIconHeight(),
BufferedImage.TYPE_INT_ARGB);
final Graphics2D graphics = image.createGraphics();
graphics.setColor(UIUtil.TRANSPARENT_COLOR);
graphics.fillRect(0, 0, icon.getIconWidth(), icon.getIconHeight());
graphics.scale(scale, scale);
icon.paintIcon(LabelHolder.ourFakeComponent, graphics, 0, 0);
graphics.dispose();
Image img = ImageUtil.filter(image, UIUtil.getGrayFilter());
if (UIUtil.isRetina()) img = RetinaImage.createFrom(img, 2, ImageLoader.ourComponent);
disabledIcon = new JBImageIcon(img);
ourIcon2DisabledIcon.put(icon, disabledIcon);
}
return disabledIcon;
}
/** [Internal] */
private void paintBackground(Graphics2D g2, Color theBackground) {
Color color1 = g2.getColor();
if (theBackground == null) theBackground = Color.white;
g2.setColor(theBackground);
g2.fillRect(0, 0, 30000, 30000);
g2.setColor(color1);
}
public void paintComponent(Graphics g) {
Graphics2D g2d = (Graphics2D) g.create();
g2d.setStroke(new BasicStroke(1.0f));
if (isOpaque()) {
g2d.setColor(getBackground());
g2d.fillRect(0, 0, getWidth(), getHeight());
}
g2d.setColor(Color.black);
g2d.drawLine(0, frameHeight / 2, frameWidth, frameHeight / 2);
g2d.drawLine(frameWidth / 2, 0, frameWidth / 2, frameHeight);
for (int i = unityX; i < frameWidth / 2; i += unityX) {
g2d.drawLine(
frameWidth / 2 + i, frameHeight / 2 - 3, frameWidth / 2 + i, frameHeight / 2 + 3);
g2d.drawLine(
frameWidth / 2 - i, frameHeight / 2 - 3, frameWidth / 2 - i, frameHeight / 2 + 3);
}
for (int i = unityY; i < frameHeight / 2; i += unityY) {
g2d.drawLine(
frameWidth / 2 - 3, frameHeight / 2 + i, frameWidth / 2 + 3, frameHeight / 2 + i);
g2d.drawLine(
frameWidth / 2 - 3, frameHeight / 2 - i, frameWidth / 2 + 3, frameHeight / 2 - i);
}
g2d.setColor(Color.blue);
function.drawFunctionToGraphic(g2d, frameWidth, frameHeight, unityX, unityY);
paintCurrentMethodState(g2d);
g2d.dispose();
}
private void paintToImage(
final BufferedImage img, final int x, final int y, final int width, final int height) {
// clear the prior image
Graphics2D imgG = (Graphics2D) img.getGraphics();
imgG.setComposite(AlphaComposite.Clear);
imgG.setColor(Color.black);
imgG.fillRect(0, 0, width + blur * 2, height + blur * 2);
final int adjX = (int) (x + blur + offsetX + (insets.left * distance));
final int adjY = (int) (y + blur + offsetY + (insets.top * distance));
final int adjW = (int) (width - (insets.left + insets.right) * distance);
final int adjH = (int) (height - (insets.top + insets.bottom) * distance);
// let the delegate paint whatever they want to be blurred
imgG.setComposite(AlphaComposite.DstAtop);
if (prePainter != null) prePainter.paint(imgG, adjX, adjY, adjW, adjH);
imgG.dispose();
// blur the prior image back into the same pixels
imgG = (Graphics2D) img.getGraphics();
imgG.setComposite(AlphaComposite.DstAtop);
imgG.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
imgG.setRenderingHint(
RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
imgG.drawImage(img, blurOp, 0, 0);
if (postPainter != null) postPainter.paint(imgG, adjX, adjY, adjW, adjH);
imgG.dispose();
}
protected void paintHorizontalPartOfLeg(
Graphics g,
Rectangle clipBounds,
Insets insets,
Rectangle bounds,
TreePath path,
int param,
boolean param6,
boolean param7,
boolean param8) {
boolean selected = treeSelectionModel.isPathSelected(path);
if (selected) {
Graphics2D g2d = (Graphics2D) g;
Color c1 = new Color(146, 163, 179);
Color c2 = new Color(82, 108, 133);
GradientPaint gradient =
new GradientPaint(0, bounds.y, c1, 0, bounds.y + bounds.height, c2, true);
g2d.setPaint(gradient);
g2d.fillRect(0, bounds.y, tree.getWidth(), bounds.height);
Color lineColor = new Color(123, 139, 157);
g2d.setColor(lineColor);
g2d.drawLine(0, bounds.y, tree.getWidth(), bounds.y);
}
// Do not call super. We dont want the lines.
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D gfx = (Graphics2D) g;
gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// Clear screen
gfx.setColor(Constants.BACKGROUND_COLOR);
gfx.fillRect(0, 0, getWidth(), getHeight());
// Render next frame
grid.draw(gfx);
// Trace path line
if (tracing) {
gfx.setColor(Constants.PATH_COLOR);
gfx.setStroke(new BasicStroke(2));
for (int i = 1; i < pathLine.size(); i++) {
Coordinate p = pathLine.get(i - 1);
Coordinate n = pathLine.get(i);
gfx.drawLine(
(Constants.TILESIZE + Constants.MARGIN) * p.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * p.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN);
}
}
}
private BufferedImage createGrid() {
if (transformCells.getScaleY() < SHOW_GRID_MIN_SCALE) {
return null;
}
Point2D cellSize = getCellSizeAfterScale();
cellWidth = round(cellSize.getX());
cellHeight = round(cellSize.getY());
BufferedImage image =
new BufferedImage(
getWidth() + 2 * (cellWidth),
getHeight() + 2 * (cellHeight),
BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics2D = image.createGraphics();
graphics2D.setColor(new Color(0, true));
graphics2D.fillRect(0, 0, image.getWidth(), image.getHeight());
graphics2D.setPaint(Color.YELLOW);
graphics2D.setStroke(new BasicStroke(1));
for (int x = 0; x < image.getWidth(); x += cellWidth) {
graphics2D.drawLine(x, 0, x, image.getHeight());
}
for (int y = 0; y < image.getHeight(); y += cellHeight) {
graphics2D.drawLine(0, y, image.getWidth(), y);
}
transformGrid.setToIdentity();
calculateGridTranslation();
graphics2D.dispose();
return image;
}
@Override
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
Color old = g2d.getColor();
// Draw box
g2d.setColor(
clicked
? this.clickedBackColor
: (hovering ? this.hoverBackColor : this.unclickedBackColor));
g2d.fillRect(0, 0, getWidth(), getHeight());
// Draw label
g2d.setColor(
clicked
? this.clickedForeColor
: (hovering ? this.hoverForeColor : this.unclickedForeColor));
g2d.setFont(getFont());
int width = g2d.getFontMetrics().stringWidth(getText());
int textHeight = getFont().getSize();
int otherTextHeight = getFontMetrics(getFont()).getHeight();
textHeight = textHeight - (otherTextHeight - textHeight);
int height = textHeight + (getHeight() - textHeight) / 2;
g2d.drawString(getText(), (getWidth() - width) / 2, height);
g2d.setColor(old);
}
// draw on screen
public synchronized void draw(Graphics2D g) {
Window w = s.getFullScreenWindow();
g.setColor(w.getBackground());
g.fillRect(0, 0, s.getWidth(), s.getHeight());
g.setColor(w.getForeground());
g.drawString(mess, 100, 100);
}
/**
* All purpose paint method that should do the right thing for all linear bouncing-box progress
* bars. Override this if you are making another kind of progress bar.
*
* @see #paintDeterminate
* @since 1.4
*/
protected void paintIndeterminate(Graphics g, JComponent c) {
if (!(g instanceof Graphics2D)) {
return;
}
Insets b = progressBar.getInsets(); // area for border
int barRectWidth = progressBar.getWidth() - (b.right + b.left);
int barRectHeight = progressBar.getHeight() - (b.top + b.bottom);
if (barRectWidth <= 0 || barRectHeight <= 0) {
return;
}
Graphics2D g2 = (Graphics2D) g;
// Paint the bouncing box.
boxRect = getBox(boxRect);
if (boxRect != null) {
g2.setColor(progressBar.getForeground());
g2.fillRect(boxRect.x, boxRect.y, boxRect.width, boxRect.height);
}
// Deal with possible text painting
if (progressBar.isStringPainted()) {
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
paintString(g2, b.left, b.top, barRectWidth, barRectHeight, boxRect.x, boxRect.width, b);
} else {
paintString(g2, b.left, b.top, barRectWidth, barRectHeight, boxRect.y, boxRect.height, b);
}
}
}
public VolatileImage renderBackgroundLayer(int LayerNumber) {
// create hardware accellerated background layer (Volatile Image)
backgroundLayer[LayerNumber] =
this.getGraphicsConfiguration()
.createCompatibleVolatileImage(
loadedLevel.getWidth() * 16,
loadedLevel.getHeight() * 16,
Transparency.TRANSLUCENT);
Graphics2D g2d = backgroundLayer[LayerNumber].createGraphics();
g2d.setComposite(AlphaComposite.Src);
// Clear the image.
g2d.setColor(new Color(0, 0, 0, 0));
g2d.fillRect(
0, 0, backgroundLayer[LayerNumber].getWidth(), backgroundLayer[LayerNumber].getHeight());
g2d.setBackground(new Color(0, 0, 0, 0));
g2d.setColor(new Color(1f, 1f, 1f, 1f));
for (int i = 0;
i
< backgroundLayer[LayerNumber].getWidth(this)
/ backgroundImage[LayerNumber].getWidth(this);
i++) {
g2d.drawImage(
backgroundImage[LayerNumber], i * backgroundImage[LayerNumber].getWidth(this), 0, this);
}
return backgroundLayer[LayerNumber];
}
public void paint(java.awt.Graphics g) {
if (element != null) {
Rectangle bounds = element.jGetBounds();
Graphics2D g2 = (Graphics2D) g;
g2.setFont(font);
int mitteX = bounds.x + (bounds.width) / 2;
int mitteY = bounds.y + (bounds.height) / 2;
int distanceY = 10;
g2.setColor(new Color(204, 204, 255));
g2.fillRect(bounds.x, mitteY - distanceY, bounds.width, 2 * distanceY);
g2.setColor(Color.BLACK);
g2.drawRect(bounds.x, mitteY - distanceY, bounds.width, 2 * distanceY);
String caption = "dec(" + variable.getValue() + ")";
FontMetrics fm = g2.getFontMetrics();
Rectangle2D r = fm.getStringBounds(caption, g2);
g2.setColor(Color.BLACK);
g.drawString(
caption, mitteX - (int) (r.getWidth() / 2), (int) (mitteY + fm.getHeight() / 2) - 3);
}
super.paint(g);
}
private BufferedImage createThumbNailImage(Dimension imgSize, ProgressMonitor pm) {
Assert.notNull(pm, "pm");
String thumbNailBandName = getThumbnailBandName();
Band thumbNailBand = product.getBand(thumbNailBandName);
Debug.trace(
"ProductSubsetDialog: Reading thumbnail data for band '" + thumbNailBandName + "'...");
pm.beginTask("Creating thumbnail image", 5);
BufferedImage image = null;
try {
MultiLevelSource multiLevelSource =
BandImageMultiLevelSource.create(thumbNailBand, SubProgressMonitor.create(pm, 1));
final ImageLayer imageLayer = new ImageLayer(multiLevelSource);
final int imageWidth = imgSize.width;
final int imageHeight = imgSize.height;
final int imageType = BufferedImage.TYPE_3BYTE_BGR;
image = new BufferedImage(imageWidth, imageHeight, imageType);
Viewport snapshotVp = new DefaultViewport(isModelYAxisDown(imageLayer));
final BufferedImageRendering imageRendering = new BufferedImageRendering(image, snapshotVp);
final Graphics2D graphics = imageRendering.getGraphics();
graphics.setColor(getBackground());
graphics.fillRect(0, 0, imageWidth, imageHeight);
snapshotVp.zoom(imageLayer.getModelBounds());
snapshotVp.moveViewDelta(snapshotVp.getViewBounds().x, snapshotVp.getViewBounds().y);
imageLayer.render(imageRendering);
pm.worked(4);
} finally {
pm.done();
}
return image;
}
private void fillRectangle(int x, int y, int width, int height, int symbolType) {
if (!Preferences.monochrome) {
setFillColor(symbolType);
gRef.fillRect(x, y, width, height);
restoreColor();
}
}
public void paint(Graphics g) {
gRef = (Graphics2D) g;
// change size of font
gRef.setFont(gRef.getFont().deriveFont(9.0f));
fmRef = g.getFontMetrics();
// Clear background
if (Preferences.monochrome) {
gRef.setColor(Preferences.whiteColor);
} else {
gRef.setColor(Preferences.backgroundColor);
}
gRef.fillRect(0, 0, getWidth(), getHeight());
// set colour to correct drawing colour
if (Preferences.monochrome) {
gRef.setColor(Preferences.blackColor);
} else {
gRef.setColor(Preferences.penColor);
}
gRef.translate(0, margin);
// Call c code to draw tree
gRef.scale(scale, scale);
nativeDrawTree();
}
/**
* Paint a background for all groups and a round blue border and background when a cell is
* selected.
*
* @param g2 the <tt>Graphics2D</tt> object through which we paint
*/
private void internalPaintComponent(Graphics2D g2) {
Color borderColor = Color.GRAY;
if (isSelected) {
g2.setPaint(
new GradientPaint(
0, 0, Constants.SELECTED_COLOR, 0, getHeight(), Constants.SELECTED_GRADIENT_COLOR));
borderColor = Constants.SELECTED_COLOR;
} else if (treeNode instanceof GroupNode) {
g2.setPaint(
new GradientPaint(
0,
0,
Constants.CONTACT_LIST_GROUP_BG_GRADIENT_COLOR,
0,
getHeight(),
Constants.CONTACT_LIST_GROUP_BG_COLOR));
borderColor = Constants.CONTACT_LIST_GROUP_BG_COLOR;
}
g2.fillRect(0, 0, getWidth(), getHeight());
g2.setColor(borderColor);
g2.drawLine(0, 0, getWidth(), 0);
g2.drawLine(0, getHeight() - 1, getWidth(), getHeight() - 1);
}
private void paintBackground(Graphics2D g, Color color, float x, int y, float width) {
if (width <= 0
|| color == null
|| color.equals(myEditor.getColorsScheme().getDefaultBackground())
|| color.equals(myEditor.getBackgroundColor())) return;
g.setColor(color);
g.fillRect((int) x, y, (int) width, myView.getLineHeight());
}
public void paint(Graphics gOld) {
if (image == null || xsize != getSize().width || ysize != getSize().height) {
xsize = getSize().width;
ysize = getSize().height;
image = createImage(xsize, ysize);
g = (Graphics2D) image.getGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
// fill background
g.setColor(Color.cyan);
g.fillRect(0, 0, xsize, ysize);
int x[] = {getX(0), getX(getWidth2()), getX(getWidth2()), getX(0), getX(0)};
int y[] = {getY(0), getY(0), getY(getHeight2()), getY(getHeight2()), getY(0)};
// fill border
g.setColor(Color.black);
g.fillPolygon(x, y, 4);
// draw border
g.setColor(Color.red);
g.drawPolyline(x, y, 5);
if (animateFirstTime) {
gOld.drawImage(image, 0, 0, null);
return;
}
if (gameOver) return;
g.drawImage(outerSpaceImage, getX(0), getY(0), getWidth2(), getHeight2(), this);
for (int index = 0; index < missile.length; index++) {
if (missile[index].active) {
g.setColor(Color.red);
drawCircle(getX(missile[index].xPos), getYNormal(missile[index].yPos), 90, .3, 1.5);
}
}
if (rocketRight) {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, 2.0, 2.0);
} else {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, -2.0, 2.0);
}
for (int index = 0; index < numStars; index++) {
g.setColor(Color.yellow);
if (starActive[index])
drawCircle(getX(starXPos[index]), getYNormal(starYPos[index]), 0, 1.5, 1.5);
}
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Score: " + score, 10, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("HighScore: " + highScore, 300, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Lives: " + rocketLife, 150, 45);
if (rocketLife == 0) {
g.setColor(Color.red);
g.setFont(new Font("Impact", Font.BOLD, 60));
g.drawString("GAME OVER", getX(getWidth2() / 6), getYNormal(getHeight2() / 2));
}
gOld.drawImage(image, 0, 0, null);
}
// initialize default image
private BufferedImage getDefaultImage(int w, int h) {
BufferedImage defaultImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics2D = defaultImage.createGraphics();
graphics2D.setColor(new Color(200, 200, 200));
graphics2D.fillRect(0, 0, w, h);
graphics2D.setColor(new Color(130, 130, 130));
graphics2D.drawRect(0, 0, w - 1, h - 1);
return defaultImage;
}
public Icon makeIcon(Color color, int width, int height) {
BufferedImage temp =
new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); // create buffered icon image
Graphics2D temp2 = temp.createGraphics();
temp2.setColor(color);
temp2.fillRect(0, 0, width, height); // draw in buffer
Icon icon = new ImageIcon(temp);
return icon;
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = ((Graphics2D) g);
g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
g2d.setRenderingHint(
RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, getWidth(), getHeight());
if (bufferedImage != null) {
synchronized (LOCKER) {
g2d.drawImage(bufferedImage, transformCells, null);
}
}
// draw struct preview
if (structurePreview != null) {
Composite composite = g2d.getComposite();
g2d.setComposite(compositeStructPreview);
g2d.drawImage(structurePreview, previewTransform, null);
g2d.setComposite(composite);
}
// draw grid
if (transformCells.getScaleX() > SHOW_GRID_MIN_SCALE) {
Composite composite = g2d.getComposite();
g2d.setComposite(compositeGrid);
g2d.drawImage(bufferedImageGrid, transformGrid, null);
g2d.setComposite(composite);
}
// draw border for preview
if (structurePreview != null && Math.abs(transformCells.getScaleX()) >= 0.95) {
Shape shape = new Rectangle(0, 0, structurePreview.getWidth(), structurePreview.getHeight());
shape = previewTransform.createTransformedShape(shape);
g2d.setColor(Color.RED);
g2d.draw(shape);
}
// draw border
double x = transformCells.getTranslateX();
double y = transformCells.getTranslateY();
g2d.setColor(BORDER_COLOR);
g2d.setStroke(new BasicStroke(BORDER_WIDTH));
g2d.drawRect(
round(x - BORDER_WIDTH),
round(y - BORDER_WIDTH),
round(getAutomatonWidth() * transformCells.getScaleX() + 2 * BORDER_WIDTH),
round(getAutomatonHeight() * transformCells.getScaleY() + 2 * BORDER_WIDTH));
}
private void paintTextEffect(
Graphics2D g, float xFrom, float xTo, int y, Color effectColor, EffectType effectType) {
int xStart = (int) xFrom;
int xEnd = (int) xTo;
g.setColor(effectColor);
if (effectType == EffectType.LINE_UNDERSCORE) {
UIUtil.drawLine(g, xStart, y + 1, xEnd, y + 1);
} else if (effectType == EffectType.BOLD_LINE_UNDERSCORE) {
int height = JBUI.scale(Registry.intValue("editor.bold.underline.height", 2));
g.fillRect(xStart, y, xEnd - xStart, height);
} else if (effectType == EffectType.STRIKEOUT) {
int y1 = y - myView.getCharHeight() / 2;
UIUtil.drawLine(g, xStart, y1, xEnd, y1);
} else if (effectType == EffectType.WAVE_UNDERSCORE) {
UIUtil.drawWave(g, new Rectangle(xStart, y + 1, xEnd - xStart, myView.getDescent() - 1));
} else if (effectType == EffectType.BOLD_DOTTED_LINE) {
UIUtil.drawBoldDottedLine(
g,
xStart,
xEnd,
SystemInfo.isMac ? y : y + 1,
myEditor.getBackgroundColor(),
g.getColor(),
false);
}
}
