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;
}
/**
* 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);
}
public void drawFunctionToGraphic(Graphics2D g, int x, int y, int UNITYX, int UNITYY) {
int _x, _y;
g.setColor(Color.red);
g.drawString("f(x) = " + F.toString(), 15, 20);
g.setColor(Color.blue);
for (double i = 0; ; i += EPSILON) {
_x = (int) (i * UNITYX) + x / 2;
_y = -(int) (F.evaluate(i) * UNITYY) + y / 2;
g.drawLine(
_x,
_y,
(int) ((i + EPSILON) * UNITYX) + x / 2,
-(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2);
if (_x < 0 || _x > x || _y < 0 || _y > y) break;
}
for (double i = 0; ; i -= EPSILON) {
_x = (int) (i * UNITYX) + x / 2;
_y = -(int) (F.evaluate(i) * UNITYY) + y / 2;
g.drawLine(
_x,
_y,
(int) ((i + EPSILON) * UNITYX) + x / 2,
-(int) (F.evaluate(i + EPSILON) * UNITYY) + y / 2);
if (_x < 0 || _x > x || _y < 0 || _y > y) break;
}
}
public void drawAxes(Graphics2D g) {
// create x and y axes
g.setColor(ALIZARIN);
g.drawLine(0, height / 2, 0, -height / 2);
g.drawLine(width / 2, 0, -width / 2, 0);
// create arrows
g.drawLine(0, -height / 2, 5, -height / 2 + 5);
g.drawLine(0, -height / 2, -5, -height / 2 + 5);
g.drawLine(width / 2, 0, width / 2 - 5, 5);
g.drawLine(width / 2, 0, width / 2 - 5, -5);
// create hatch marks and coordinate numbers for x and y axis.
int interval = (int) (zoom / 2);
double coordinateNumber;
String numberMark;
for (int i = 0; i <= height / 2 - interval; i += zoom) {
g.drawLine(-HATCH_LENGTH, i, HATCH_LENGTH, i);
g.drawLine(-HATCH_LENGTH, -i, HATCH_LENGTH, -i);
coordinateNumber = i / zoom;
if (i != 0) {
numberMark = String.format("%2.0f", -coordinateNumber);
if (i % 2 == 0) g2.drawString(numberMark, 0 - HATCH_LENGTH - 18, i + 5);
numberMark = String.format("%2.0f", coordinateNumber);
g2.drawString(numberMark, 0 - HATCH_LENGTH - 18, -i + 5);
}
}
for (int i = 0; i < width / 2 - interval; i += zoom) {
g.drawLine(i, HATCH_LENGTH, i, -HATCH_LENGTH);
g.drawLine(-i, HATCH_LENGTH, -i, -HATCH_LENGTH);
coordinateNumber = i / zoom;
if (i != 0) {
numberMark = String.format("%2.0f", coordinateNumber);
g2.drawString(numberMark, i - 6, 0 - HATCH_LENGTH - 5);
numberMark = String.format("%2.0f", -coordinateNumber);
g2.drawString(numberMark, -i - 6, 0 - HATCH_LENGTH - 3);
}
}
}
private static void drawSierpinskyTriangle(int level, int x, int y, int size, Graphics2D g) {
if (level <= 0) return;
g.drawLine(x, y, x + size, y);
g.drawLine(x, y, x, y + size);
g.drawLine(x + size, y, x, y + size);
drawSierpinskyTriangle(level - 1, x, y, size / 2, g);
drawSierpinskyTriangle(level - 1, x + size / 2, y, size / 2, g);
drawSierpinskyTriangle(level - 1, x, y + size / 2, size / 2, g);
}
public void drawGrid(Graphics2D g) {
g.setColor(WET_ASPHALT);
for (int i = 0; i < height; i += zoom) {
g.drawLine(i, -height / 2, i, height / 2);
g.drawLine(-i, -height / 2, -i, height / 2);
}
for (int i = 0; i < width; i += zoom) {
g.drawLine(-width / 2, i, width / 2, i);
g.drawLine(-width / 2, -i, width / 2, -i);
}
}
public static void paintButtonGroupLines(
RadRootContainer rootContainer, RadButtonGroup group, Graphics g) {
List<RadComponent> components = rootContainer.getGroupContents(group);
if (components.size() < 2) return;
Rectangle[] allBounds = new Rectangle[components.size()];
int lastTop = -1;
int minLeft = Integer.MAX_VALUE;
for (int i = 0; i < components.size(); i++) {
final Rectangle rc =
SwingUtilities.convertRectangle(
components.get(i).getParent().getDelegee(),
components.get(i).getBounds(),
rootContainer.getDelegee());
allBounds[i] = rc;
minLeft = Math.min(minLeft, rc.x);
if (i == 0) {
lastTop = rc.y;
} else if (lastTop != rc.y) {
lastTop = Integer.MIN_VALUE;
}
}
Graphics2D g2d = (Graphics2D) g;
Stroke oldStroke = g2d.getStroke();
g2d.setStroke(new BasicStroke(2.0f));
g2d.setColor(new Color(104, 107, 130));
if (lastTop != Integer.MIN_VALUE) {
// all items in group have same Y
int left = Integer.MAX_VALUE;
int right = Integer.MIN_VALUE;
for (Rectangle rc : allBounds) {
final int midX = (int) rc.getCenterX();
left = Math.min(left, midX);
right = Math.max(right, midX);
g2d.drawLine(midX, lastTop - 8, midX, lastTop);
}
g2d.drawLine(left, lastTop - 8, right, lastTop - 8);
} else {
int top = Integer.MAX_VALUE;
int bottom = Integer.MIN_VALUE;
for (Rectangle rc : allBounds) {
final int midY = (int) rc.getCenterY();
top = Math.min(top, midY);
bottom = Math.max(bottom, midY);
g2d.drawLine(minLeft - 8, midY, rc.x, midY);
}
g2d.drawLine(minLeft - 8, top, minLeft - 8, bottom);
}
g2d.setStroke(oldStroke);
}
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.
}
/**
* Draws a double headed arrow with arrow heads of a given width and height.
*
* @param aG the canvas to draw on;
* @param aX1 the starting X position of the arrow;
* @param aY1 the starting Y position of the arrow;
* @param aX2 the ending X position of the arrow;
* @param aY2 the ending Y position of the arrow;
* @param aArrowWidth the total width of the arrow head;
* @param aArrowHeight the total height of the arrow head.
*/
public static final void drawDoubleHeadedArrow(
final Graphics aG,
final int aX1,
final int aY1,
final int aX2,
final int aY2,
final int aArrowWidth,
final int aArrowHeight) {
final Graphics2D g2d = (Graphics2D) aG.create();
final int lineWidth = Math.abs(aX2 - aX1);
final int threshold = (2 * aArrowWidth) + 2;
try {
int x1 = aX1;
int x2 = aX2;
if (lineWidth > threshold) {
drawArrowHead(g2d, aX1, aY1, LEFT_FACING, aArrowWidth, aArrowHeight);
// why x2 needs to be shifted by one pixel is beyond me...
drawArrowHead(g2d, aX2 + 1, aY2, RIGHT_FACING, aArrowWidth, aArrowHeight);
x1 += aArrowWidth - 1;
x2 -= aArrowWidth + 1;
}
g2d.drawLine(x1, aY1, x2, aY2);
} finally {
g2d.dispose();
}
}
// From: http://forum.java.sun.com/thread.jspa?threadID=378460&tstart=135
void drawArrow(
Graphics2D g2d,
int xCenter,
int yCenter,
int x,
int y,
float stroke,
BasicStroke drawStroke) {
double aDir = Math.atan2(xCenter - x, yCenter - y);
// Line can be dashed.
g2d.setStroke(drawStroke);
g2d.drawLine(x, y, xCenter, yCenter);
// make the arrow head solid even if dash pattern has been specified
g2d.setStroke(lineStroke);
Polygon tmpPoly = new Polygon();
int i1 = 12 + (int) (stroke * 2);
// make the arrow head the same size regardless of the length length
int i2 = 6 + (int) stroke;
tmpPoly.addPoint(x, y);
tmpPoly.addPoint(x + xCor(i1, aDir + .5), y + yCor(i1, aDir + .5));
tmpPoly.addPoint(x + xCor(i2, aDir), y + yCor(i2, aDir));
tmpPoly.addPoint(x + xCor(i1, aDir - .5), y + yCor(i1, aDir - .5));
tmpPoly.addPoint(x, y); // arrow tip
g2d.drawPolygon(tmpPoly);
// Remove this line to leave arrow head unpainted:
g2d.fillPolygon(tmpPoly);
}
/** {@inheritDoc} */
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
g2d.setBackground(Color.white);
int xDim = (int) (getWidth() / 56);
int yDim = (int) (getHeight() / 66);
g2d.drawLine(0, (agent[0].length) * yDim, Slope.getWidth() * xDim, (agent[0].length) * yDim);
g2d.drawRect((Slope.getWidth() - 3) * xDim, 0, 15, Slope.getHeight() * yDim);
for (int k = 0; k < Slope.getHeight(); k++)
for (int l = 0; l < Slope.getWidth(); l++) {
g2d.setColor(new Color(0, 0, 0, 1));
g2d.drawRect(k * getWidth() / 56, l * getHeight() / 66, 30, 30);
}
for (int i = 0; i < agent.length; i++) {
for (int j = 0; j < agent[0].length; j++) {
g2d.setColor(Color.blue);
if (agent[i][j]) {
// g2d.drawString("*", i*getWidth()/56, j*getHeight()/66);
g2d.drawImage(image, i * getWidth() / 56, j * getHeight() / 66, null);
}
}
}
}
@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);
}
}
}
public void StaticObjNew(StaticObj so) {
Graphics2D g = radarArea.backImage.createGraphics();
g.setColor(so_color);
if (so instanceof Beacon) {
g.drawOval(
convPos(so.pos.x) - grid_size / 6,
convPos(so.pos.y) - grid_size / 6,
grid_size / 3,
grid_size / 3);
JLabel sol = new JLabel(Integer.toString(so.id));
sol.setForeground(so_text_color);
sol.setBounds(
convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2);
radarArea.add(sol, new Integer(1));
}
if (so instanceof Airfield) {
int xa[] = new int[3], ya[] = new int[3];
int l1 = grid_size / 2, l2 = grid_size / 6;
xa[0] = convPos(so.pos.x);
ya[0] = convPos(so.pos.y);
xa[1] = convPos(so.pos.x) - l1 * so.dir.x - l2 * so.dir.y;
ya[1] = convPos(so.pos.y) - l1 * so.dir.y + l2 * so.dir.x;
xa[2] = convPos(so.pos.x) - l1 * so.dir.x + l2 * so.dir.y;
ya[2] = convPos(so.pos.y) - l1 * so.dir.y - l2 * so.dir.x;
g.drawPolygon(xa, ya, 3);
JLabel sol = new JLabel(Integer.toString(so.id));
sol.setForeground(so_text_color);
sol.setBounds(
convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2);
radarArea.add(sol, new Integer(1));
}
if (so instanceof Exit) {
g.drawRect(
convPos(so.pos.x) - grid_size / 6,
convPos(so.pos.y) - grid_size / 6,
grid_size / 3,
grid_size / 3);
JLabel sol = new JLabel(Integer.toString(so.id));
sol.setForeground(so_text_color);
sol.setBounds(
convPos(so.pos.x) + grid_size / 6, convPos(so.pos.y), grid_size / 3, grid_size / 2);
radarArea.add(sol, new Integer(1));
}
if (so instanceof Line) {
g.setColor(line_color);
g.drawLine(
convPos(((Line) so).pos.x),
convPos(((Line) so).pos.y),
convPos(((Line) so).second_end.x),
convPos(((Line) so).second_end.y));
}
radarArea.backIcon = new ImageIcon(radarArea.backImage);
radarArea.back.setIcon(radarArea.backIcon);
}
@Override
protected void paintCheckSign(Graphics2D g, boolean enabled, int w, int h) {
g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
g.setStroke(
new BasicStroke(JBUI.scale(1) * 2.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g.setPaint(getShadowColor(enabled, true));
final int x1 = JBUI.scale(5);
final int y1 = JBUI.scale(9);
final int x2 = JBUI.scale(7);
final int y2 = JBUI.scale(11);
g.drawLine(x1, y1, x2, y2);
g.drawLine(x2, y2, w - JBUI.scale(2) - 1, JBUI.scale(5));
g.setPaint(getCheckSignColor(enabled, true));
g.drawLine(x1, y1 - 2, x2, y2 - 2);
g.drawLine(x2, y2 - 2, w - JBUI.scale(2) - 1, JBUI.scale(5) - 2);
}
/** PaintComponent to draw everything. */
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
setBackground(Color.WHITE);
// If using images, use cool dragon background
if (useImages) g.drawImage(background, 0, 0, 310, 300, null);
// Use light gray to not overpower the background image
g.setColor(Color.LIGHT_GRAY);
for (int y = 1; y < ROWS; ++y)
g.fillRoundRect(0, cellSize * y - 4, (cellSize * COLS) - 1, 8, 8, 8);
for (int x = 1; x < COLS; ++x)
g.fillRoundRect(cellSize * x - 4, 0, 8, (cellSize * ROWS) - 1, 8, 8);
// Use graphics2d for when not using the images
Graphics2D g2d = (Graphics2D) g;
g2d.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
for (int y = 0; y < ROWS; ++y) {
for (int x = 0; x < COLS; ++x) {
int x1 = x * cellSize + 16;
int y1 = y * cellSize + 16;
if (board[y][x] == Symbol.X) {
// use image if set to true, otherwise use g2d
// for thicker, better looking X's and O's
if (useImages) g.drawImage(imageX, x1, y1, 75, 75, null);
else {
g2d.setColor(PURPLE);
int x2 = (x + 1) * cellSize - 16;
int y2 = (y + 1) * cellSize - 16;
g2d.drawLine(x1, y1, x2, y2);
g2d.drawLine(x2, y1, x1, y2);
}
} else if (board[y][x] == Symbol.O) {
if (useImages) g.drawImage(imageO, x1, y1, 75, 75, null);
else {
g2d.setColor(Color.BLUE);
g2d.drawOval(x1, y1, 70, 70);
}
}
} // end for
}
// Set status bar based on gamestate. If CONTINUE, show whose turn it is
if (gameStatus == GameStatus.CONTINUE) {
statusBar.setForeground(Color.BLACK);
if (currentPlayer == Symbol.X) statusBar.setText("X's Turn");
else statusBar.setText("O's Turn");
} else if (gameStatus == GameStatus.DRAW) {
statusBar.setForeground(Color.RED);
statusBar.setText("Draw! Click to play again!");
} else if (gameStatus == GameStatus.X_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("X has won! Click to play again!");
} else if (gameStatus == GameStatus.O_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("O has won! Click to play again!");
}
}
public void plot(Color c, int x0, int y0, int z0) {
Graphics2D g = bi.createGraphics();
g.setColor(c);
if (x0 >= XRES || y0 >= YRES || x0 < 0 || y0 < 0) return;
if (z0 > zbuffer[x0][y0]) {
g.drawLine(x0, y0, x0, y0);
zbuffer[x0][y0] = z0;
}
}
public static void drawRound3DBorder(Graphics g, Color c1, Color c2, int x, int y, int w, int h) {
Graphics2D g2D = (Graphics2D) g;
int x2 = x + w;
int y2 = y + h;
int d = h;
int r = h / 2;
Color cm = ColorHelper.median(c1, c2);
Color c1m = ColorHelper.median(c1, cm);
Color c2m = ColorHelper.median(c2, cm);
Object savedRederingHint = g2D.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// oben
g2D.setColor(c1);
g2D.drawLine(x + r, y, x2 - r, y);
// rechts
g2D.drawLine(x, y + r, x, y2 - r);
// unten
g2D.setColor(c2);
g2D.drawLine(x + r, y2, x2 - r, y2);
// links
g2D.drawLine(x2, y + r, x2, y2 - r);
// links
g2D.setColor(c1);
g2D.drawArc(x, y, d, d, 90, 45);
g2D.setColor(c1m);
g2D.drawArc(x, y, d, d, 135, 45);
g2D.setColor(cm);
g2D.drawArc(x, y, d, d, 180, 45);
g2D.setColor(c2m);
g2D.drawArc(x, y, d, d, 225, 45);
// rechts
g2D.setColor(c1m);
g2D.drawArc(x2 - d, y, d, d, 45, 45);
g2D.setColor(cm);
g2D.drawArc(x2 - d, y, d, d, 0, 45);
g2D.setColor(c2m);
g2D.drawArc(x2 - d, y, d, d, -45, 45);
g2D.setColor(c2);
g2D.drawArc(x2 - d, y, d, d, -90, 45);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, savedRederingHint);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
Insets i = getInsets();
// int y = g2.getFontMetrics().getHeight()*getLineAtCaret(this)+i.top;
int y = caret.y + caret.height - 1;
g2.setPaint(cfc);
g2.drawLine(i.left, y, getSize().width - i.left - i.right, y);
}
private void quadriller(Graphics2D g) {
float dash[] = {2f, 0f, 2f};
BasicStroke pointilles =
new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash, 2f);
g.setStroke(pointilles);
for (int i = 1; i <= Parametres.NB_TRAVEES - 1; i++) {
g.drawLine(
Parametres.LARGEUR_TRAVEE * i,
0,
Parametres.LARGEUR_TRAVEE * i,
Parametres.NB_RANGEES * Parametres.HAUTEUR_RANGEE - 1);
}
for (int i = 1; i <= Parametres.NB_RANGEES - 1; i++) {
g.drawLine(
0,
Parametres.HAUTEUR_RANGEE * i,
Parametres.NB_TRAVEES * Parametres.LARGEUR_TRAVEE - 1,
Parametres.HAUTEUR_RANGEE * i);
}
}
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();
}
/**
* @param points
* @param color
* @param g
*/
private void paintSequence(
Slot type, List<List<ValuePointColored>> points, Color color, Graphics2D g) {
int i = 0;
int size = points.size();
if (size > 0) {
double increment = 200 / size;
for (List<ValuePointColored> valuePoints : points) {
int alpha = (int) (i * increment) + 55;
Color c = new Color(color.getRed(), color.getGreen(), color.getBlue(), alpha);
for (ValuePointColored valuePoint : valuePoints) {
double[] coordinates = valuePoint.getPoint().toArray();
int x = xToPix(coordinates[0]);
int y = yToPix(coordinates[1]);
// if minimum then red, else black
if (valuePoint.getBest() == true) {
g.setColor(Color.red);
} else {
g.setColor(c);
}
g.setStroke(LINE);
switch (type) {
case CIRCLE:
g.drawOval(x - RADIUS / 2 - 3, y - RADIUS / 2 - 3, RADIUS * 2, RADIUS * 2);
break;
case SQUARE:
g.drawRect(x - RADIUS / 2 - 2, y - RADIUS / 2 - 2, RADIUS * 2 - 2, RADIUS * 2 - 2);
break;
case TRIANGLE:
GeneralPath polyline = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 3);
polyline.moveTo(x, y - RADIUS / 2 - 4);
polyline.lineTo(x + RADIUS / 2 + 3, y + RADIUS / 2 + 1);
polyline.lineTo(x - RADIUS / 2 - 3, y + RADIUS / 2 + 1);
polyline.closePath();
g.draw(polyline);
break;
case CROSS:
int xLow = x - RADIUS / 2 - 1;
int xHigh = x + RADIUS / 2 + 1;
int yLow = y - RADIUS / 2 - 1;
int yHigh = y + RADIUS / 2 + 1;
g.drawLine(xLow, yLow, xHigh, yHigh);
g.drawLine(xHigh, yLow, xLow, yHigh);
break;
}
}
i++;
}
}
}
@Override
public void paintBorder(Component component, Graphics g, int x, int y, int width, int height) {
Graphics2D g2 = (Graphics2D) g;
g2.setPaint(getBoundsColor());
int horMargin = myOuterMargin.left + myOuterMargin.right;
int vertMargin = myOuterMargin.top + myOuterMargin.bottom;
g2.drawRect(
x + myOuterMargin.left,
y + myOuterMargin.top,
x + width - 3 - horMargin,
y + height - 3 - vertMargin);
g2.setPaint(myShade1);
g2.drawLine(
x + 1 + myOuterMargin.left,
y + height - 2 - myOuterMargin.bottom,
x + width - 2 - myOuterMargin.right,
y + height - 2 - myOuterMargin.bottom);
g2.drawLine(
x + width - 2 - myOuterMargin.right,
y + 1 + myOuterMargin.bottom,
x + width - 2 - myOuterMargin.right,
y + height - 2 - myOuterMargin.bottom);
g2.setPaint(myShade2);
g2.drawLine(
x + 2 + myOuterMargin.left,
y + height - 1 - myOuterMargin.bottom,
x + width - 1 - myOuterMargin.right,
y + height - 1 - myOuterMargin.bottom);
g2.drawLine(
x + width - 1 - myOuterMargin.right,
y + 2 + myOuterMargin.top,
x + width - 1 - myOuterMargin.right,
y + height - 1 - myOuterMargin.bottom);
}
@Override
public void paintComponent(Graphics g) {
final JLabel lbl = CHomeUI.SINGLETON_INSTANCE.getLblSelected();
int yTop = (lbl.getY() + lbl.getParent().getY());
// super.paintComponent(g);
final Graphics2D g2d = (Graphics2D) g.create();
final int w = getWidth();
final int h = getHeight();
FSkin.setGraphicsColor(g2d, d20);
// Selected in this group, don't draw background under selected label.
if (getY() < yTop && yTop < getY() + h) {
g2d.fillRect(0, 0, w, lbl.getY());
g2d.fillRect(0, lbl.getY() + lbl.getHeight(), w, h);
FSkin.setGraphicsGradientPaint(g2d, w - 8, 0, l00, w, 0, d80);
g2d.fillRect(w - 6, 0, w, lbl.getY());
g2d.fillRect(w - 6, lbl.getY() + lbl.getHeight(), w, h);
}
// Selected not in this group; draw full background.
else {
g2d.fillRect(0, 0, w, h);
FSkin.setGraphicsGradientPaint(g2d, w - 8, 0, l00, w, 0, d80);
g2d.fillRect(w - 6, 0, w, h);
}
FSkin.setGraphicsColor(g2d, l10);
g2d.drawLine(0, h - 1, w - 1, h - 1);
FSkin.setGraphicsColor(g2d, d60);
g2d.drawLine(0, 0, w - 1, 0);
g2d.dispose();
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g.create();
if (getModel().isPressed()) {
g2.translate(1, 1);
}
g2.setStroke(new BasicStroke(2));
g2.setColor(Color.BLACK);
if (getModel().isRollover()) {
g2.setColor(Color.WHITE);
}
int delta = 6;
g2.drawLine(delta, delta, getWidth() - delta - 1, getHeight() - delta - 1);
g2.drawLine(getWidth() - delta - 1, delta, delta, getHeight() - delta - 1);
g2.dispose();
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
bg.paintIcon(this, g2, 0, 0);
TreeMap<Integer, FactoryObject> to = (TreeMap<Integer, FactoryObject>) fos.clone();
for (Integer i : to.keySet()) {
FactoryObject t = to.get(i);
if (t.getIsLine()) {
g2.setColor(Color.WHITE);
g2.drawLine(t.getPositionX(), t.getPositionY(), t.getPositionXF(), t.getPositionYF());
} else {
if (t.getImageIndex() >= 0) {
ImageIcon tmp = images.getIcon(t.getImageIndex());
tmp.paintIcon(this, g2, t.getPositionX(), t.getPositionY());
}
}
}
}
/**
* A paint class that will draw the needle, dots, and TO/FROM RenderingHints is IMPORTANT. It
* will make sure that everything stays focused and not blurry whenever the image rotates. I
* added an empty line between the 8 fillArcs, just so its easier to see that four of them
* draw on the left side and four draw on the right side.
*/
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
RenderingHints hints = new RenderingHints(null);
hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g2.setRenderingHints(hints);
g2.setStroke(new BasicStroke(3));
// g2.drawString("TO", 190, 200);
if (vor.isTo() == true) {
if (vor.isAbeamed() == true) {
// g2.setFont(new Font("default", Font.BOLD, 16));
// g2.setColor(Color.red);
// g2.drawString("BAD", 190, 200);
} else {
// g2.setFont(new Font("default", Font.BOLD, 16));
g2.drawString("TO", 190, 200);
}
} else if (vor.isFrom() == true) {
if (vor.isAbeamed() == true) {
// g2.setFont(new Font("default", Font.BOLD, 16));
// g2.setColor(Color.red);
// g2.drawString("BAD", 190, 300);
} else {
// g2.setFont(new Font("default", Font.BOLD, 13));
g2.drawString("FROM", 190, 300);
}
} else if (vor.isFrom() == false || vor.isTo() == false) {
// is above the vor station no to or from
}
g2.fillArc(140, 240, 7, 7, 0, 360);
g2.fillArc(125, 240, 7, 7, 0, 360);
g2.fillArc(110, 240, 7, 7, 0, 360);
g2.fillArc(95, 240, 7, 7, 0, 360);
g2.fillArc(195, 240, 7, 7, 0, 360);
g2.fillArc(210, 240, 7, 7, 0, 360);
g2.fillArc(225, 240, 7, 7, 0, 360);
g2.fillArc(240, 240, 7, 7, 0, 360);
// g2.drawString("FROM",190, 300);
g2.drawLine(x, y1, x, y2);
super.paintComponent(g);
g2.dispose();
}
private void renderClusters() {
Graphics2D g2 = workImage.createGraphics();
FastQueue<Polygon2D_F64> squares = alg.getFindSeeds().getDetectorSquare().getFound();
for (int i = 0; i < squares.size(); i++) {
Polygon2D_F64 p = squares.get(i);
g2.setColor(Color.black);
g2.setStroke(new BasicStroke(4));
VisualizeShapes.drawPolygon(p, true, g2, true);
g2.setColor(Color.white);
g2.setStroke(new BasicStroke(2));
VisualizeShapes.drawPolygon(p, true, g2, true);
}
List<SquareGrid> grids = alg.getFindSeeds().getGrids().getGrids();
for (int i = 0; i < grids.size(); i++) {
SquareGrid g = grids.get(i);
int a = grids.size() == 1 ? 0 : 255 * i / (grids.size() - 1);
int rgb = a << 16 | (255 - a) << 8;
g2.setStroke(new BasicStroke(3));
for (int j = 0; j < g.nodes.size() - 1; j++) {
double fraction = j / ((double) g.nodes.size() - 1);
fraction = fraction * 0.6 + 0.4;
int lineRGB = (int) (fraction * a) << 16 | (int) (fraction * (255 - a)) << 8;
g2.setColor(new Color(lineRGB));
SquareNode p0 = g.nodes.get(j);
SquareNode p1 = g.nodes.get(j + 1);
g2.drawLine((int) p0.center.x, (int) p0.center.y, (int) p1.center.x, (int) p1.center.y);
}
g2.setColor(new Color(rgb));
for (int j = 0; j < g.nodes.size(); j++) {
SquareNode n = g.nodes.get(j);
VisualizeShapes.drawPolygon(n.corners, true, g2, true);
}
}
}
private void tracerVisualisations(Graphics2D g) {
float dash[] = {2f, 0f, 2f};
BasicStroke pointilles =
new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash, 2f);
g.setStroke(pointilles);
g.setColor(Color.red);
for (PlanSalle.Poste poste : modele.listerPostes()) {
int centreX =
Parametres.centrePersonneX(poste.getPosition().getTravee(), poste.getOrientation());
int centreY =
Parametres.centrePersonneY(poste.getPosition().getRangee(), poste.getOrientation());
for (PlanSalle.Poste posteVisible : poste.getPostesVisibles()) {
int visibleX = Parametres.centrePositionX(posteVisible.getPosition().getTravee());
int visibleY = Parametres.centrePositionY(posteVisible.getPosition().getRangee());
g.drawLine(centreX, centreY, visibleX, visibleY);
}
}
}
/**
* Paints a custom gradient background for selected cells.
*
* @param g the <tt>Graphics</tt> object used for painting
*/
private void internalPaintComponent(Graphics g) {
AntialiasingManager.activateAntialiasing(g);
Graphics2D g2 = (Graphics2D) g;
int width = getWidth();
int height = getHeight();
if (this.isSelected) {
GradientPaint p =
new GradientPaint(
width / 2, 0, SELECTED_START_COLOR, width / 2, height, SELECTED_END_COLOR);
g2.setPaint(p);
g2.fillRoundRect(1, 1, width, height - 1, 7, 7);
}
g2.setColor(SELECTED_START_COLOR);
g2.drawLine(0, height - 1, width, height - 1);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (images == null || selectedImage >= images.size()) return;
BufferedImage image = images.get(selectedImage);
double scaleX = getWidth() / (double) image.getWidth();
double scaleY = getHeight() / (double) image.getHeight();
double scale = Math.min(1, Math.min(scaleX, scaleY));
AffineTransform tranOrig = g2.getTransform();
AffineTransform tran = g2.getTransform();
tran.concatenate(AffineTransform.getScaleInstance(scale, scale));
g2.setTransform(tran);
if (showUndistorted) {
if (undoRadial != null && !isUndistorted) {
undoRadialDistortion(image);
isUndistorted = true;
}
g2.drawImage(undistorted, 0, 0, null);
} else g2.drawImage(image, 0, 0, null);
g2.setTransform(tranOrig);
if (features.size() > selectedImage) {
drawFeatures(g2, scale);
}
if (lineY > -1) {
g2.setColor(Color.RED);
g2.setStroke(new BasicStroke(3));
g2.drawLine(0, lineY, getWidth(), lineY);
}
}