/**
* 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;
}
/**
* Draws an open star with a specified number of points.<br>
* The center of this star is specified by centerX,centerY and its size is specified by radius
* <br>
* (As in the radius of the circle the star would fit inside). <br>
* Precondition: points >= 2 <br>
* Example: <br>
* Expo.drawStar(g,300,200,100,8); <br>
* Draws an open star with 8 points and a radius of 100 pixels whose center is located at the
* coordinate (300,200).
*/
public static void drawStar(Graphics g, int centerX, int centerY, int radius, int points) {
int halfRadius = getHalfRadius(radius, points);
int p = points;
points *= 2;
int xCoord[] = new int[points];
int yCoord[] = new int[points];
int currentRadius;
for (int k = 0; k < points; k++) {
if (k % 2 == 0) currentRadius = radius;
else currentRadius = halfRadius;
xCoord[k] = (int) Math.round(Math.cos(twoPI * k / points - halfPI) * currentRadius) + centerX;
yCoord[k] = (int) Math.round(Math.sin(twoPI * k / points - halfPI) * currentRadius) + centerY;
}
int x = (p - 5) / 2 + 1;
if (p >= 5 && p <= 51)
switch (p % 4) {
case 1:
yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x];
break;
case 2:
yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x];
yCoord[x + 3] = yCoord[x + 4] = yCoord[points - x - 4] = yCoord[points - x - 3];
break;
case 3:
yCoord[x + 2] = yCoord[x + 3] = yCoord[points - x - 3] = yCoord[points - x - 2];
}
g.drawPolygon(xCoord, yCoord, points);
}
private void computeMarketsSize(Dimension panelDimensions) {
double rowMaxLenght = 8d * panelDimensions.getWidth() / 9d;
// check when the column of of workers start
double halfheight = panelDimensions.getHeight() / 2d;
marketYStart = 2d * halfheight / 5d + halfheight;
marketYEnd = 3d * halfheight / 5d + halfheight;
marketFirstX = rowMaxLenght / 9d;
marketLastX = 8d * rowMaxLenght / 9d;
double rowRealLenght = marketLastX - marketFirstX;
marketRadius = (rowRealLenght * 3d) / (4d * new Double(GoodType.values().length));
marketSpacing = marketRadius / 3d;
int index = 0;
for (GoodType x : GoodType.values()) {
Point a =
new Point(
(int) Math.round(marketFirstX + index * (marketRadius + marketSpacing)),
(int) Math.round((marketYStart + marketYEnd) / 2d));
marketPlace.put(x, a);
index++;
}
}
private void computeFirmSizes(Dimension panelDimensions) {
ArrayList<Firm> firms = SleepStoneTest.firms;
double rowMaxLenght = 8d * panelDimensions.getWidth() / 9d;
// check when the column of of workers start
double halfheight = panelDimensions.getHeight() / 2d;
firmYStart = halfheight / 3d;
firmYEnd = 2d * halfheight / 3d;
firmFirstX = rowMaxLenght / 11d;
firmLastX = 10d * rowMaxLenght / 11d;
double rowRealLenght = firmLastX - firmFirstX;
firmLenght = (rowRealLenght * 3d) / (4d * new Double(firms.size()));
firmSpacing = firmLenght / 3d;
// compute the rectangles
for (int i = 0; i < firms.size(); i++) {
Rectangle location =
new Rectangle(
(int) Math.round(firmFirstX + i * (firmLenght + firmSpacing)),
(int) Math.round(firmYStart),
(int) Math.round(firmLenght),
(int) Math.round(firmYEnd - firmYStart));
System.out.println(location);
firmsPlace.put(firms.get(i), location);
tradersPlace.put(
firms.get(i), new Point((int) location.getCenterX(), (int) location.getCenterY()));
}
}
public void mouseClicked(MouseEvent e) {
int x;
int y;
e.consume();
if (mouseEventsEnabled) {
x = Math.round(e.getX() / scale);
y = Math.round(e.getY() / scale);
// allow for the canvas margin
y -= margin;
// System.out.println("Mouse Click: (" + x + ", " + y + ")");
if (e.getClickCount() < 2) {
if (nativeSelectItem(x, y)) {
parentFTAFrame.updateFrame();
}
} else {
if (nativeSelectItem(x, y)) {
parentFTAFrame.updateFrame();
}
editSelected();
parentFTAFrame.updateFrame();
}
if (focusEventsEnabled) {
// tell the main Canvas to point to this coordinate
parentFTAFrame.setCanvasFocus(x, y);
}
}
}
void ajustarYCentrar(JComponent porAjustar, JComponent ajustador) {
// Se agregan 30 de alto y 6 de ancho por adornos de la ventana
porAjustar.setSize(
ajustador.getMinimumSize().getSize().width + 16,
ajustador.getMinimumSize().getSize().height + 44);
int x = Math.round(Principal.sysAncho / 2) - Math.round(porAjustar.getBounds().width / 2);
int y = Math.round(Principal.sysAlto / 2) - Math.round(porAjustar.getBounds().height / 2);
porAjustar.setLocation(x, y);
}
private void paintFirms(Graphics2D g2d) {
Rectangle2D rec = new Rectangle2D.Double();
ArrayList<Firm> firms = SleepStoneTest.firms;
Stroke normalStroke = new BasicStroke();
Stroke boldStroke = new BasicStroke(4f);
g2d.setStroke(boldStroke);
for (Firm x : firms) {
rec.setRect(firmsPlace.get(x));
FirmStatus status = x.getStatus();
g2d.setColor(Color.black);
g2d.drawString(x.getFirmName(), Math.round(rec.getMinX()), Math.round(rec.getMaxY() + 15d));
g2d.drawString(
Integer.toString(x.getWorkers().size()),
Math.round(rec.getMinX()),
Math.round(rec.getMinY() - 15d));
// g2d.setColor(Color.RED);
g2d.drawImage(
firmIcon.getImage(),
(int) rec.getX(),
(int) rec.getY(),
(int) rec.getWidth(),
(int) rec.getHeight(),
FirmStatus.getStatusColor(status),
null);
// draw the jobs done indicator
if (status == FirmStatus.PRODUCING) {
g2d.setColor(Color.black);
g2d.setStroke(boldStroke);
Rectangle jobsIndicator =
new Rectangle(
(int) rec.getMaxX() + 5,
(int) rec.getMinY(),
(int) (firmSpacing / 2d),
(int) rec.getHeight());
g2d.draw(jobsIndicator);
float jobsToDo = x.getJobsToDo();
float jobsDone = x.getJobsDone().availablePermits();
float percentComplete = jobsDone / jobsToDo;
g2d.setColor(Color.BLUE);
jobsIndicator.setBounds(
(int) rec.getMaxX() + 5,
(int) rec.getMinY(),
(int) (firmSpacing / 2d),
(int) (((float) (rec.getHeight())) * percentComplete));
g2d.fill(jobsIndicator);
g2d.setStroke(normalStroke);
}
// index++;
}
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y).
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
offscreen.drawImage(
image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), null);
draw();
}
public static BufferedImage scaleImage(BufferedImage bi, double scale) {
int w1 = (int) (Math.round(scale * bi.getWidth()));
int h1 = (int) (Math.round(scale * bi.getHeight()));
BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w1, h1);
g2.drawImage(bi, 0, 0, w1, h1, null); // this);
g2.dispose();
return image;
}
/**
* This determines the amount of the progress bar that should be filled based on the percent done
* gathered from the model. This is a common operation so it was abstracted out. It assumes that
* your progress bar is linear. That is, if you are making a circular progress indicator, you will
* want to override this method.
*/
protected int getAmountFull(Insets b, int width, int height) {
int amountFull = 0;
BoundedRangeModel model = progressBar.getModel();
if ((model.getMaximum() - model.getMinimum()) != 0) {
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
amountFull = (int) Math.round(width * progressBar.getPercentComplete());
} else {
amountFull = (int) Math.round(height * progressBar.getPercentComplete());
}
}
return amountFull;
}
private int getRandom(int max, int min, int current, boolean isSmoothed, int svf) {
if (isSmoothed) {
int offset = (max - min) * svf / 100;
double mx = current + offset;
max = (mx > max) ? max : (int) Math.round(mx);
double mn = current - offset;
min = (mn < min) ? min : (int) Math.round(mn);
}
double rnd = Math.random() * (max - min) + min;
return (int) Math.round(rnd);
}
/**
* When the ERASE or SMUDGE tools are used and the mouse jumps from (x1,y1) to (x2,y2), the tool
* has to be applied to a line of pixel positions between the two points in order to cover the
* entire line that the mouse moves along. The change is made to the off-screen canvas, and
* repaint() is called to copy the changes to the screen.
*/
void applyToolAlongLine(int x1, int y1, int x2, int y2) {
Graphics g = OSC.getGraphics();
g.setColor(fillColor); // (for ERASE only)
int w = OSC.getWidth(); // (for SMUDGE only)
int h = OSC.getHeight(); // (for SMUDGE only)
int dist = Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1));
// dist is the number of points along the line from
// (x1,y1) to (x2,y2) at which the tool will be applied.
double dx = (double) (x2 - x1) / dist;
double dy = (double) (y2 - y1) / dist;
for (int d = 1; d <= dist; d++) {
// Apply the tool at one of the points (x,y) along the
// line from (x1,y1) to (x2,y2).
int x = (int) Math.round(x1 + dx * d);
int y = (int) Math.round(y1 + dy * d);
if (currentTool == Tool.ERASE) {
// Erase a 10-by-10 block of pixels around (x,y)
g.fillRect(x - 5, y - 5, 10, 10);
repaint(x - 5, y - 5, 10, 10);
} else {
// For the SMUDGE tool, blend some of the color from
// the smudgeRed, smudgeGreen, and smudgeBlue arrays
// into the pixels in a 7-by-7 block around (x,y), and
// vice versa. The effect is to smear out the color
// of pixels that are visited by the tool.
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7; j++) {
int r = y + j - 3;
int c = x + i - 3;
if (!(r < 0 || r >= h || c < 0 || c >= w || smudgeRed[i][j] == -1)) {
int curCol = OSC.getRGB(c, r);
int curRed = (curCol >> 16) & 0xFF;
int curGreen = (curCol >> 8) & 0xFF;
int curBlue = curCol & 0xFF;
int newRed = (int) (curRed * 0.7 + smudgeRed[i][j] * 0.3);
int newGreen = (int) (curGreen * 0.7 + smudgeGreen[i][j] * 0.3);
int newBlue = (int) (curBlue * 0.7 + smudgeBlue[i][j] * 0.3);
int newCol = newRed << 16 | newGreen << 8 | newBlue;
OSC.setRGB(c, r, newCol);
smudgeRed[i][j] = curRed * 0.3 + smudgeRed[i][j] * 0.7;
smudgeGreen[i][j] = curGreen * 0.3 + smudgeGreen[i][j] * 0.7;
smudgeBlue[i][j] = curBlue * 0.3 + smudgeBlue[i][j] * 0.7;
}
}
}
repaint(x - 3, y - 3, 7, 7);
}
}
g.dispose();
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param degrees is the number of degrees to rotate counterclockwise
* @throws IllegalArgumentException if the image is corrupt
*/
public static void picture(double x, double y, String s, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
offscreen.drawImage(
image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), null);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
draw();
}
// public void savePDF(){
// Rectangle suggestedPageSize = getITextPageSize(page1.getPageSize());
// Rectangle pageSize = rotatePageIfNecessary(suggestedPageSize);
// //rotate if we need landscape
// Document document = new Document(pageSize);
//
// PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(outputFile));
// document.open();
// Graphics2D graphics = cb.createGraphics(pageSize.getWidth(), pageSize.getHeight());
//
// // call your GTRenderer here
// GTRenderer draw = new StreamingRenderer();
// draw.setMapContent(mapContent);
//
// draw.paint(graphics, outputArea, mapContent.getLayerBounds() );
//
// // cleanup
// graphics.dispose();
//
// //cleanup
// document.close();
// writer.close();
// }
public void saveImage(final MapContent map, final String file, final int imageWidth) {
GTRenderer renderer = new StreamingRenderer();
renderer.setMapContent(map);
Rectangle imageBounds = null;
ReferencedEnvelope mapBounds = null;
try {
mapBounds = map.getMaxBounds();
double heightToWidth = mapBounds.getSpan(1) / mapBounds.getSpan(0);
imageBounds = new Rectangle(0, 0, imageWidth, (int) Math.round(imageWidth * heightToWidth));
} catch (Exception e) {
// failed to access mapContent layers
throw new RuntimeException(e);
}
BufferedImage image =
new BufferedImage(imageBounds.width, imageBounds.height, BufferedImage.TYPE_INT_RGB);
Graphics2D gr = image.createGraphics();
gr.setPaint(Color.WHITE);
gr.fill(imageBounds);
try {
renderer.paint(gr, imageBounds, mapBounds);
File fileToSave = new File(file);
ImageIO.write(image, "jpeg", fileToSave);
} catch (Exception e) {
e.printStackTrace();
}
}
public UpgradesPanel(ORUIManager orUIManager) {
super(BoxLayout.Y_AXIS);
this.orUIManager = orUIManager;
preferredSize = new Dimension((int) Math.round(100 * (2 + Scale.getFontScale()) / 3), 200);
setSize(preferredSize);
setVisible(true);
upgradePanel = new JPanel();
upgradePanel.setOpaque(true);
upgradePanel.setBackground(Color.DARK_GRAY);
upgradePanel.setBorder(border);
upgradePanel.setLayout(new GridLayout(defaultNbPanelElements, 1));
scrollPane = new JScrollPane(upgradePanel);
scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
scrollPane.setSize(getPreferredSize());
doneButton.setActionCommand("Done");
doneButton.setMnemonic(KeyEvent.VK_D);
doneButton.addActionListener(this);
cancelButton.setActionCommand("Cancel");
cancelButton.setMnemonic(KeyEvent.VK_C);
cancelButton.addActionListener(this);
add(scrollPane);
}
/**
* Draws an open regular polygon with a specified number of sides.<br>
* The center of this polygon is specified by centerX,centerY and its size is specified by radius
* <br>
* (As in the radius of the circle the regular polygon would fit inside). <br>
* Precondition: sides >= 3 <br>
* Example: Expo.drawRegularPolygon(g,300,200,100,8); Draws an open regular octagon with a radius
* of 100 pixels whose center is located at the coordinate (300,200).
*/
public static void drawRegularPolygon(
Graphics g, int centerX, int centerY, int radius, int sides) {
int xCoord[] = new int[sides];
int yCoord[] = new int[sides];
double rotate;
if (sides % 2 == 1) rotate = halfPI;
else rotate = halfPI + Math.PI / sides;
for (int k = 0; k < sides; k++) {
xCoord[k] = (int) Math.round(Math.cos(twoPI * k / sides - rotate) * radius) + centerX;
yCoord[k] = (int) Math.round(Math.sin(twoPI * k / sides - rotate) * radius) + centerY;
}
if (sides == 3) yCoord[1] = yCoord[2];
g.drawPolygon(xCoord, yCoord, sides);
}
public static void smoothFillInverseHorGradient(
Graphics g, Color[] colors, int x, int y, int w, int h) {
if (colors != null) {
Graphics2D g2D = (Graphics2D) g;
Paint savedPaint = g2D.getPaint();
int steps = colors.length;
double dy = (double) h / (double) steps;
int y1 = y;
for (int i = 0; i < steps; i++) {
int y2 = y + (int) Math.round((double) i * dy);
g.setColor(colors[colors.length - i - 1]);
if (i == (steps - 1)) {
g2D.setPaint(null);
g2D.setColor(colors[colors.length - i - 1]);
g.fillRect(x, y1, w, y + h - y1);
} else {
g2D.setPaint(
new GradientPaint(
0, y1, colors[colors.length - i - 1], 0, y2, colors[colors.length - i - 2]));
g.fillRect(x, y1, w, y2 - y1);
}
y1 = y2;
}
g2D.setPaint(savedPaint);
}
}
/**
* Called by the paint method to draw the graph and its graph items.
*
* @param g the graphics context.
*/
public void paintComponent(Graphics g) {
Dimension dim = getSize();
Insets insets = getInsets();
dataArea =
new Rectangle(
insets.left,
insets.top,
dim.width - insets.left - insets.right - 1,
dim.height - insets.top - insets.bottom - 1);
// background
if (isOpaque()) {
g.setColor(getBackground());
g.fillRect(0, 0, dim.width, dim.height);
}
g.setColor(getForeground());
// get axis tickmarks
double xticks[] = xAxis.getTicks();
double yticks[] = yAxis.getTicks();
int yb = dataArea.y + dataArea.height;
// draw grid
if (showGrid) {
g.setColor(gridColor != null ? gridColor : getBackground().darker());
// vertical x grid lines
for (int i = 0; i < xticks.length; i += 2) {
int x = dataArea.x + (int) Math.round(xticks[i]);
g.drawLine(x, dataArea.y, x, dataArea.y + dataArea.height);
}
// horizontal y grid lines
for (int i = 0; i < yticks.length; i += 2) {
int y = yb - (int) Math.round(yticks[i]);
g.drawLine(dataArea.x, y, dataArea.x + dataArea.width, y);
}
}
for (int i = 0; i < graphItems.size(); i++) {
((GraphItem) graphItems.elementAt(i)).draw(this, g, dataArea, xAxis, yAxis);
}
if (sPt != null && ePt != null) {
g.setColor(getForeground());
g.drawRect(
Math.min(sPt.x, ePt.x), Math.min(sPt.y, ePt.y),
Math.abs(ePt.x - sPt.x), Math.abs(ePt.y - sPt.y));
}
}
/**
* Returns the percentage, like 5.
*
* @param chosen the numerator
* @param total the denominator
* @return the percent
*/
public static int percent(int chosen, int total) {
if (total == 0) {
// dividing by 0 is bad; just return 0%
return 0;
}
// let's say we had 2,3 passed
double decimal = chosen / (total + 0.0); // 2/3.0 is 0.6666
int percent = (int) (Math.round(decimal * 100)); // 0.6666 * 100 ~= 0.67 (we're rounding)
return percent;
}
/** Prototype give player a leveled up look */
public void Opify(double Fac) {
for (int i = 0; i < imgCHARAC.getWidth(); i++) {
for (int j = 0; j < imgCHARAC.getHeight(); j++) {
if (imgCHARAC.getRGB(i, j) != imgCHARAC.getRGB(2, 2)) {
imgCHARAC.setRGB(i, j, (int) Math.round(imgCHARAC.getRGB(i, j) * Fac));
}
}
}
}
/**
* Designate the place where the progress string will be painted. This implementation places it at
* the center of the progress bar (in both x and y). Override this if you want to right, left,
* top, or bottom align the progress string or if you need to nudge it around for any reason.
*/
protected Point getStringPlacement(
Graphics g, String progressString, int x, int y, int width, int height) {
FontMetrics fontSizer = SwingUtilities2.getFontMetrics(progressBar, g, progressBar.getFont());
int stringWidth = SwingUtilities2.stringWidth(progressBar, fontSizer, progressString);
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
return new Point(
x + Math.round(width / 2 - stringWidth / 2),
y
+ ((height + fontSizer.getAscent() - fontSizer.getLeading() - fontSizer.getDescent())
/ 2));
} else { // VERTICAL
return new Point(
x
+ ((width - fontSizer.getAscent() + fontSizer.getLeading() + fontSizer.getDescent())
/ 2),
y + Math.round(height / 2 - stringWidth / 2));
}
}
public int getHeight() {
float fHeight;
int height;
fHeight = scale * nativeGetMaxDepth();
height = Math.round(fHeight) + (2 * margin);
if (parentContainer == null) {
return height;
} else {
return FTAUtilities.max(height, parentContainer.getHeight());
}
}
public int getWidth() {
float fWidth;
int width;
fWidth = scale * nativeGetMaxWidth();
width = Math.round(fWidth);
if (parentContainer == null) {
return width;
} else {
return FTAUtilities.max(width, parentContainer.getWidth());
}
}
/**
* Updates progress bar progress line every time a progress event has been received.
*
* @param event the <tt>FileTransferProgressEvent</tt> that notified us
*/
public void progressChanged(FileTransferProgressEvent event) {
progressBar.setValue((int) event.getProgress());
long transferredBytes = event.getFileTransfer().getTransferedBytes();
long progressTimestamp = event.getTimestamp();
ByteFormat format = new ByteFormat();
String bytesString = format.format(transferredBytes);
if ((progressTimestamp - lastSpeedTimestamp) >= SPEED_CALCULATE_DELAY) {
lastProgressSpeed = Math.round(calculateProgressSpeed(transferredBytes));
this.lastSpeedTimestamp = progressTimestamp;
this.lastTransferredBytes = transferredBytes;
}
if ((progressTimestamp - lastEstimatedTimeTimestamp) >= SPEED_CALCULATE_DELAY
&& lastProgressSpeed > 0) {
lastEstimatedTime =
Math.round(
calculateEstimatedTransferTime(
lastProgressSpeed, transferredFileSize - transferredBytes));
lastEstimatedTimeTimestamp = progressTimestamp;
}
progressBar.setString(getProgressLabel(bytesString));
if (lastProgressSpeed > 0) {
progressSpeedLabel.setText(
resources.getI18NString("service.gui.SPEED") + format.format(lastProgressSpeed) + "/sec");
progressSpeedLabel.setVisible(true);
}
if (lastEstimatedTime > 0) {
estimatedTimeLabel.setText(
resources.getI18NString("service.gui.ESTIMATED_TIME")
+ GuiUtils.formatSeconds(lastEstimatedTime * 1000));
estimatedTimeLabel.setVisible(true);
}
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees, rescaled
* to w-by-h.
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param w the width of the image
* @param h the height of the image
* @param degrees is the number of degrees to rotate counterclockwise
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double w, double h, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(w);
double hs = factorY(h);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
if (ws <= 1 && hs <= 1) pixel(x, y);
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
offscreen.drawImage(
image,
(int) Math.round(xs - ws / 2.0),
(int) Math.round(ys - hs / 2.0),
(int) Math.round(ws),
(int) Math.round(hs),
null);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
draw();
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y), rescaled to w-by-h.
*
* @param x the center x coordinate of the image
* @param y the center y coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param w the width of the image
* @param h the height of the image
* @throws RuntimeException if the width height are negative
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double w, double h) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
if (w < 0) throw new RuntimeException("width is negative: " + w);
if (h < 0) throw new RuntimeException("height is negative: " + h);
double ws = factorX(w);
double hs = factorY(h);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
if (ws <= 1 && hs <= 1) pixel(x, y);
else {
offscreen.drawImage(
image,
(int) Math.round(xs - ws / 2.0),
(int) Math.round(ys - hs / 2.0),
(int) Math.round(ws),
(int) Math.round(hs),
null);
}
draw();
}
private int[] setUpNearest(MouseEvent e) {
int mousex = e.getX() - _display_offset[0];
int mousey = e.getY() - _display_offset[1];
int i = 0;
int j;
j = (int) Math.round((mousey - hextop) * 1.0 / intervalUp);
if ((j % 2 + (rings - 1) % 2) == 0 || (((j - 1) % 2 + (rings) % 2) == 0)) {
int glob = 1;
for (i = 0;
(Math.floor((i + 1) / 2) * radius + Math.floor(i / 2) * radius * 2)
< mousex - hexleft - radius / 2;
i++) glob += (((i % 2) == 0) ? 1 : 3);
double dx =
(Math.floor((i + 1) / 2) * radius + Math.floor(i / 2) * radius * 2)
- (mousex - hexleft - radius / 2);
if ((i % 2) == 1 && dx > radius / 2) {
i = i - 1;
glob -= 1;
} else if ((i % 2) == 0 && dx > radius) {
i = i - 1;
glob -= 3;
}
i = glob;
} else {
int glob = 0;
for (i = 0;
(Math.floor((i + 1) / 2) * radius * 2 + Math.floor(i / 2) * radius) < mousex - hexleft;
i++) glob += (((i % 2) == 0) ? 3 : 1);
double dx =
(Math.floor((i + 1) / 2) * radius * 2 + Math.floor(i / 2) * radius) - (mousex - hexleft);
if ((i % 2) == 0 && dx > radius / 2) {
i = i - 1;
glob -= 1;
} else if ((i % 2) == 1 && dx > radius) {
i = i - 1;
glob -= 3;
}
i = glob;
}
return new int[] {i, j};
}
private void paintDevice(Graphics g, Device d) {
// reads the robot's current position
model.getRobot().readPosition(d.getRobotPosition());
Polygon currentShape = d.getShape();
// draws the shape
Polygon globalShape = new Polygon();
Point2D point = new Point2D.Double();
for (int i = 0; i < currentShape.npoints; i++) {
point.setLocation(currentShape.xpoints[i], currentShape.ypoints[i]);
// calculates the coordinates of the point according to the local position
d.getLocalPosition().rotateAroundAxis(point);
// calculates the coordinates of the point according to the robot position
d.getRobotPosition().rotateAroundAxis(point);
// adds the point to the global shape
globalShape.addPoint((int) Math.round(point.getX()), (int) Math.round(point.getY()));
}
g.setColor(d.getBackgroundColor());
g.fillPolygon(globalShape);
g.setColor(d.getForegroundColor());
g.drawPolygon(globalShape);
}
public static void fillVerGradient(Graphics g, Color[] colors, int x, int y, int w, int h) {
int steps = colors.length;
double dx = (double) w / (double) steps;
int x1 = x;
for (int i = 0; i < steps; i++) {
int x2 = x + (int) Math.round((double) i * dx);
g.setColor(colors[i]);
if (i == (steps - 1)) {
g.fillRect(x1, y, x + w - x1, h);
} else {
g.fillRect(x1, y, x2 - x1, h);
}
x1 = x2;
}
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
if (isSelected) this.setBackground(table.getSelectionBackground());
else this.setBackground(table.getBackground());
Node node = nodes.get(row);
Request request = nodeIDToRequest.get(node.getNodeID());
if (request == null) {
this.setString("NONE");
this.setValue(0);
} else {
int percent = (int) Math.round(request.getPercentDone());
this.setString(request.getType().toString() + " " + percent + "%");
this.setValue(percent);
}
return this;
}