/**
* Draws as much as possible of a given string into a 2d square region in a graphical space.
*
* @param g component onto which to draw
* @param f font to use in drawing the string
* @param s string to be drawn
* @param xPos
* @param yPos
* @param width
* @param height
*/
public static void drawStringMultiline(
Graphics2D g, Font f, String s, double xPos, double yPos, double width, double height) {
FontMetrics fm = g.getFontMetrics(f);
int w = fm.stringWidth(s);
int h = fm.getAscent();
// g.setColor(Color.LIGHT_GRAY);
g.setColor(Color.BLACK);
g.setFont(f);
Scanner lineSplitter = new Scanner(s);
// draw as much as can fit in each item
// read all content from scanner, storing in string lists (where each string == 1 line), each
// string should be as long as possible without overflowing the space
int maxRows = (int) height / h;
List<String> textRows = new ArrayList<>();
while (lineSplitter.hasNextLine() && textRows.size() < maxRows) {
String line = lineSplitter.nextLine();
// if line is blank, insert to maintain paragraph seps
if (line.trim().equals("")) {
textRows.add("");
}
// else, pass to inner loop
StringBuilder currentBuilder = new StringBuilder();
int currentStrWidth = 0;
Scanner splitter = new Scanner(line);
while (splitter.hasNext() && textRows.size() < maxRows) {
String token = splitter.next() + " ";
// TODO incorporate weight detection, formatting for token?
currentStrWidth += fm.stringWidth(token);
if (currentStrWidth >= width) {
// if string length >= glyph width, build row
textRows.add(currentBuilder.toString());
currentBuilder = new StringBuilder();
currentBuilder.append(token);
currentStrWidth = fm.stringWidth(token);
} else {
// if not yet at end of row, append to builder
currentBuilder.append(token);
}
}
// if we've still space and still have things to write, add them here
if (textRows.size() < maxRows) {
textRows.add(currentBuilder.toString());
currentBuilder = new StringBuilder();
currentStrWidth = 0;
}
}
// write each line to object
for (int t = 0; t < textRows.size(); t++) {
String line = textRows.get(t);
if (fm.stringWidth(line) <= width) {
// ensure that string doesn't overflow the box
// g.drawString(line, (float) (xPos-(width/2.)), (float) (yPos-(height/2.) +
// h * (t+1)));
g.drawString(line, (float) xPos, (float) (yPos + h * (t + 1)));
}
}
}
public void draw(node leaf, Graphics2D g, int px, int py) {
int lvl = leaf.getLevel();
double l = lvl;
counts[lvl]++;
double xfraq = counts[lvl] / (spacing[lvl] + 1);
double yfraq = l / depth;
int x = new Double(1600 * xfraq).intValue();
int y = new Double(1200 * yfraq).intValue() + 10;
if (leaf.getAttr() != null) {
g.drawString(leaf.getAttr(), x - 20, y);
}
if (leaf.getCrit() != null) {
g.drawString(leaf.getCrit(), x - 20, y + 10);
}
if (leaf.getResult() != null) {
g.drawString(leaf.getResult(), x - 20, y + 10);
}
g.drawLine(x, y, px, py);
// g.fillRect(x,y,20,20);
ArrayList children = leaf.getChildren();
while (!children.isEmpty()) {
draw((node) children.remove(0), g, x, y);
}
}
private void drawString(String str, int x, int y) {
// text does not work correctly for very small scales.
if (textEnabled && scale > 0.05) {
gRef.drawString(str, x, y);
}
}
/**
* paintComponent schreibt alle Laendernamen an die entsprechende Stelle der Landkarte
* (Hintergrundgrafik) und zeichnet die Laendergrenzen auf der Landkarte nach.
*
* @param g Zeichenflaeche der Landkarte
*/
public void paintComponent(Graphics g) {
Shape shape;
Graphics2D g2d = (Graphics2D) g;
g2d.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
Font myFont = new Font("Times New Roman", Font.BOLD, 12);
g2d.setFont(myFont);
g2d.setStroke(new BasicStroke(2.0f));
Territory territory;
Color color;
ListIterator territories = worldMap.getTerritories().listIterator();
while (territories.hasNext()) {
territory = (Territory) territories.next();
if (territory.getOwner() != null) {
color = territory.getOwner().getPlayerColor();
} else {
color = Color.WHITE;
}
g2d.setColor(color);
g2d.drawString(
territory.getName(),
(int) territory.getMidpoint().getX() - 15,
(int) territory.getMidpoint().getY() - 10);
g2d.drawString(
new Integer(territory.getArmySize()).toString(),
(int) territory.getMidpoint().getX(),
(int) territory.getMidpoint().getY());
}
if (territoryBattle.size() != 0) {
for (int j = 0; j < territoryBattle.size(); j++) {
g2d.setColor(territoryBattle.get(j).getOwner().getPlayerColor());
// g2d.fillPolygon(territoryTmp.getFrontiers()); Sieht bei unseren Grenzen nicht huebsch
// aus
g2d.drawPolygon(territoryBattle.get(j).getFrontiers());
}
}
repaint();
}
public void paint(Graphics screen) {
Graphics2D screen2D = (Graphics2D) screen;
Font type = new Font("Monospaced", Font.BOLD, 20);
screen2D.setFont(type);
GregorianCalendar day = new GregorianCalendar();
String time = day.getTime().toString();
screen2D.setColor(back);
screen2D.drawString(lastTime, 5, 25);
screen2D.setColor(butterscotch);
screen2D.drawString(time, 5, 25);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// do nothing
}
lastTime = time;
repaint();
}
/**
* A rendering method to draw this label to the given Graphics2D object, with the additional
* option of allowing the "long" lines to be drawn. Due to the fact that the relative drawing
* point of a state is its x and y co-ordinates and for a Transition there is a workOutMiddle()
* method, the relative x and y values must be supplied to this method. Usually this method will
* be called from inside a Transition render method or a State render method.
*
* @param g2 the Graphics2D component upon which to draw this label.
* @param x the x position upon which to make relative co-ordinates exact.
* @param y the y position upon which to make relative co-ordinates exact.
* @param longLines flag to determine whether the long version of this label should be drawn.
*/
public void render(Graphics2D g2, double x, double y, boolean longLines) {
intersects(new Rectangle2D.Double(0, 0, 1, 1));
StringTokenizer tokens = new StringTokenizer(getRenderString(), "\n");
if (selected) {
g2.setColor(Color.green);
} else {
g2.setColor(theColour);
}
g2.setFont(theFont);
int i = 0;
boolean doneLong = false;
while (tokens.hasMoreTokens()) {
if (doneLong)
g2.drawString(
tokens.nextToken(),
(float) (x + offsetX),
(float) (y + offsetY + ((i * (theFont.getSize() + 2)))));
else {
if (!longLines)
g2.drawString(
tokens.nextToken().trim(),
(float) (x + offsetX),
(float) (y + offsetY + ((i * (theFont.getSize()))) + 2));
else
g2.drawString(
getName() + ": " + tokens.nextToken().trim(),
(float) (x + offsetX),
(float) (y + offsetY + ((i * (theFont.getSize()))) + 2));
}
i++;
doneLong = true;
}
/*if(intersects != null)
{
g2.setColor(Color.magenta);
for(int j = 0; j < intersects.size(); j++)
{
Rectangle2D rect = (Rectangle2D)intersects.get(j);
g2.draw(rect);
}
}*/
}
/** Draw vertices on top of the edge structure */
public void drawNodes(Graphics2D gg) {
Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
// Run through the traversal and draw each vertex
// using an Ellipse2D
// The draw point has been determined previously in
// calcNodeCoords()
while (nodeList.hasMoreElements()) {
TreeVertex vertex = (TreeVertex) nodeList.nextElement();
// Don't draw virtual nodes
if (vertex.isVirtual()) continue;
// If tree is incomplete and we're on the top layer, skip it
if (argument.isMultiRoots() && vertex.getLayer() == 0) continue;
Point corner = vertex.getDrawPoint();
Shape node = new Ellipse2D.Float(corner.x, corner.y, NODE_DIAM, NODE_DIAM);
vertex.setShape(node, this);
// Fill the interior of the node with vertex's fillPaint
gg.setPaint(vertex.fillPaint);
gg.fill(node);
// Draw the outline with vertex's outlinePaint; bold if selected
gg.setPaint(vertex.outlinePaint);
if (vertex.isSelected()) {
gg.setStroke(selectStroke);
} else {
gg.setStroke(solidStroke);
}
gg.draw(node);
// Draw the short label on top of the vertex
gg.setPaint(vertex.textPaint);
String shortLabelString = new String(vertex.getShortLabel());
if (shortLabelString.length() == 1) {
gg.setFont(labelFont1);
gg.drawString(shortLabelString, corner.x + NODE_DIAM / 4, corner.y + 3 * NODE_DIAM / 4);
} else if (shortLabelString.length() == 2) {
gg.setFont(labelFont2);
gg.drawString(shortLabelString, corner.x + NODE_DIAM / 5, corner.y + 3 * NODE_DIAM / 4);
}
}
}
public void draw(Graphics2D graphic) {
setForegroundColor(colorString);
graphic.fill(shape);
if (text != null) {
setForegroundColor("black");
java.awt.Rectangle bounds = shape.getBounds();
int x = bounds.x + bounds.width / 2;
int y = bounds.y + bounds.height / 2;
graphic.drawString(text, x, y);
}
}
public void draw(Graphics2D g) {
g.setColor(fillColor);
g.fill(gp);
g.setColor(Color.black);
g.draw(gp);
for (int i = 0; i < points.size(); i++) {
GlyphPoint p = points.get(i);
g.setColor(Color.red);
g.draw(p.gp);
g.setColor(Color.blue);
g.setFont(gfont);
g.drawString(String.valueOf(i), p.x + 3, p.y + 3);
}
g.setColor(Color.black);
// System.out.println("Advance: "+advance);
g.draw(advp);
if (name != null) {
g.setFont(gfont);
g.drawString(name, 0, -40);
}
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (!text.equals("")) {
g2.translate(0, getSize().getHeight());
g2.rotate(-Math.PI / 2);
g2.setColor(Color.black);
g2.drawString(text, 20, 14);
g2.translate(0, -getSize().getHeight());
g2.transform(AffineTransform.getQuadrantRotateInstance(1));
}
}
// draws the tree, starting from the given node, in the region with x values
// ranging
// from minX to maxX, with y value beginning at y, and next level at y +
// yIncr.
private void drawTree(Graphics2D g2, TreeNode<E> t, int minX, int maxX, int y, int yIncr) {
// skip if empty
if (t == null) return;
// compute useful coordinates
int x = (minX + maxX) / 2;
int nextY = y + yIncr;
// draw black lines
g2.setPaint(Color.black);
if (t.left != null) {
int nextX = (minX + x) / 2;
g2.draw(new Line2D.Double(x, y, nextX, nextY));
}
if (t.right != null) {
int nextX = (x + maxX) / 2;
g2.draw(new Line2D.Double(x, y, nextX, nextY));
}
// measure text
FontMetrics font = g2.getFontMetrics();
String text = t.data + "";
int textHeight = font.getHeight();
int textWidth = font.stringWidth(text);
// draw the box around the node
Rectangle2D.Double box =
new Rectangle2D.Double(
x - textWidth / 2 - ARC_PAD,
y - textHeight / 2 - ARC_PAD,
textWidth + 2 * ARC_PAD,
textHeight + 2 * ARC_PAD);
Color c = new Color(187, 224, 227);
g2.setPaint(c);
g2.fill(box);
// draw black border
g2.setPaint(Color.black);
g2.draw(box);
// draw text
g2.drawString(text, x - textWidth / 2, y + textHeight / 2);
// draw children
drawTree(g2, t.left, minX, x, nextY, yIncr);
drawTree(g2, t.right, x, maxX, nextY, yIncr);
}
/** @see prefuse.render.Renderer#render(java.awt.Graphics2D, prefuse.visual.VisualItem) */
@Override
public void render(Graphics2D g, VisualItem item) {
Shape s = getShape(item);
GraphicsLib.paint(g, item, m_line, getStroke(item), getRenderType(item));
// check if we have a text label, if so, render it
String str;
if (item.canGetString(VisualItem.LABEL)) {
str = (String) item.getString(VisualItem.LABEL);
if (str != null && !str.equals("")) {
float x = (float) m_box.getMinX();
float y = (float) m_box.getMinY() + m_ascent;
// draw label background
GraphicsLib.paint(g, item, s, null, RENDER_TYPE_FILL);
AffineTransform origTransform = g.getTransform();
AffineTransform transform = this.getTransform(item);
if (transform != null) {
g.setTransform(transform);
}
g.setFont(item.getFont());
g.setColor(ColorLib.getColor(item.getTextColor()));
if (!(str.length() > 5
&& str.substring(str.length() - 5, str.length()).equals("_last"))) {
g.setColor(Color.WHITE);
// TODO properly hunt down source of null str! for now, triage
if (str != null) {
// bump y down by appropriate amount
FontMetrics fm = g.getFontMetrics(item.getFont());
int strHeight = fm.getAscent();
// g.drawString(str, x, y);
g.drawString(str, x, y + strHeight);
}
if (transform != null) {
g.setTransform(origTransform);
}
}
}
}
}
public void paintItem(Graphics2D g, int x1, int y1, int x2, int y2) {
if (!canPaint()) {
return;
}
Iterator<ScoredRegion> regions = model.getResults();
while (regions.hasNext()) {
ScoredRegion r = regions.next();
int minx = getXPos(r.getStart(), getRegion().getStart(), getRegion().getEnd(), x1, x2);
int maxx = getXPos(r.getEnd(), getRegion().getStart(), getRegion().getEnd(), x1, x2);
float percent = (float) (1.0 - r.getScore() / maxScore);
g.setColor(new Color(percent, percent, percent, (float) 1.0));
g.fillRect(minx, y1, maxx - minx, (y2 - y1));
}
if (props.DrawTrackLabel) {
g.setColor(new Color((float) 0.0, (float) 0.0, (float) 0.0, (float) 0.5));
g.drawString(getLabel(), x1, y2);
}
}
void renderUI(Graphics2D g2d) {
g2d.setFont(new Font("Courier New", Font.PLAIN, 12));
g2d.setColor(Color.white);
if (removeMode) g2d.setColor(Color.black);
if (player.health < 0) player.health = 0;
g2d.drawString(String.format("Helath: %s", player.health), 10, 20);
g2d.drawString(String.format("Kills: %s", player.score), 10, 40);
int WLevel = (Integer) player.weapon[player.currentWeapon][10];
if (WLevel == 5)
g2d.drawString(String.format("Current Weapon: %s:Max", player.currentWeapon), 10, 60);
else
g2d.drawString(String.format("Current Weapon: %s:%s", player.currentWeapon, WLevel), 10, 60);
g2d.setColor(Color.gray);
g2d.drawString(String.format("Level: %s", difficulty), 10, 80);
g2d.setColor(Color.black);
if (showDebug) g2d.drawString(String.format("FPS: %s", fps), 10, 100);
if (cheated) g2d.drawString("You cheated, no highscore will be saved", 200, height - 15);
}
private void drawTile(Graphics g2, Tile tile, int x, int y) {
Graphics2D g = ((Graphics2D) g2);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
int value = tile.value;
int xOffset = offsetCoors(x);
int yOffset = offsetCoors(y);
g.setColor(tile.getBackground());
g.fillRoundRect(xOffset, yOffset, TILE_SIZE, TILE_SIZE, 14, 14);
g.setColor(tile.getForeground());
final int size = value < 100 ? 36 : value < 1000 ? 32 : 24;
final Font font = new Font(FONT_NAME, Font.BOLD, size);
g.setFont(font);
String s = String.valueOf(value);
final FontMetrics fm = getFontMetrics(font);
final int w = fm.stringWidth(s);
final int h = -(int) fm.getLineMetrics(s, g).getBaselineOffsets()[2];
if (value != 0)
g.drawString(s, xOffset + (TILE_SIZE - w) / 2, yOffset + TILE_SIZE - (TILE_SIZE - h) / 2 - 2);
if (myWin || myLose) {
g.setColor(new Color(255, 255, 255, 30));
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(new Color(78, 139, 202));
g.setFont(new Font(FONT_NAME, Font.BOLD, 48));
if (myWin) {
g.drawString("You won!", 68, 150);
}
if (myLose) {
g.drawString("Game over!", 50, 130);
g.drawString("You lose!", 64, 200);
}
if (myWin || myLose) {
g.setFont(new Font(FONT_NAME, Font.PLAIN, 16));
g.setColor(new Color(128, 128, 128, 128));
g.drawString("Press ESC to play again", 80, getHeight() - 40);
}
}
g.setFont(new Font(FONT_NAME, Font.PLAIN, 18));
g.drawString("Score: " + myScore, 200, 365);
}
boolean eventHandeler(Graphics2D g2d) {
if (keyboard.keyDownOnce(KeyEvent.VK_Q)) {
window.setState(Frame.ICONIFIED);
paused = true;
}
if (firstStartup) {
g2d.setColor(Color.white);
g2d.fill(new Rectangle(0, 0, width, height));
g2d.setFont(new Font("Courier New", Font.PLAIN, 20));
g2d.setColor(Color.black);
switch (startupPage) {
case 1:
if (keyboard.keyDownOnce(KeyEvent.VK_SPACE)) startupPage = 2;
g2d.drawString("The goal of this game is to kill as", 100, 170);
g2d.drawString("many *zombies* as possible. You are", 100, 200);
g2d.drawString("given weapons and power-ups to help", 100, 230);
g2d.drawString("you succeed. Good luck.", 100, 260);
g2d.setColor(Color.gray);
g2d.drawString("Press SPACE to continue", 150, 330);
g2d.drawString("Ø O O", 280, 290);
g2d.setColor(Color.black);
g2d.setFont(new Font("Courier New", Font.PLAIN, 34));
g2d.drawString("Story", 265, 110);
break;
case 2:
if (keyboard.keyDownOnce(KeyEvent.VK_SPACE)) startupPage = 3;
g2d.drawString("Use A,S,D,W to stear", 100, 170);
g2d.drawString("Use 1,2,3,4 to change weapon", 100, 200);
g2d.drawString("Use the MOUSE to aim", 100, 230);
g2d.drawString("Use the LEFT MOUSE BUTTON to fire", 100, 260);
g2d.setColor(Color.gray);
g2d.drawString("Press SPACE to continue", 150, 330);
g2d.drawString("O Ø O", 280, 290);
g2d.setColor(Color.black);
g2d.setFont(new Font("Courier New", Font.PLAIN, 34));
g2d.drawString("Controlls", 230, 110);
break;
case 3:
if (keyboard.keyDownOnce(KeyEvent.VK_SPACE)) firstStartup = false;
g2d.setColor(Color.black);
g2d.draw(new Ellipse2D.Double(100, 170 - 15, 20, 20));
g2d.setColor(Color.red);
g2d.draw(new Ellipse2D.Double(100, 200 - 15, 20, 20));
g2d.setColor(Color.blue);
g2d.draw(new Ellipse2D.Double(100, 230 - 15, 20, 20));
g2d.setColor(Color.green);
g2d.draw(new Ellipse2D.Double(100, 260 - 15, 20, 20));
g2d.setColor(Color.black);
g2d.drawString("Is you", 130, 170);
g2d.drawString("Heals you", 130, 200);
g2d.drawString("Unlocks / upgrades a weapon", 130, 230);
g2d.drawString("Causes an explosion around you", 130, 260);
g2d.setColor(Color.gray);
g2d.drawString("Press SPACE to start", 150, 330);
g2d.drawString("O O Ø", 280, 290);
g2d.setColor(Color.black);
g2d.setFont(new Font("Courier New", Font.PLAIN, 34));
g2d.drawString("Power-ups", 230, 110);
break;
}
return true;
}
if (player.isDead) {
g2d.setColor(Color.white);
g2d.fill(new Rectangle(0, 0, width, height));
if (keyboard.keyDownOnce(KeyEvent.VK_R)) restart();
if (newHighscore) {
int x = 20;
int y = 130;
g2d.rotate(-.4, x, y);
g2d.setFont(new Font("Comic Sans MS", Font.PLAIN, 40));
g2d.setColor(Color.black);
Stroke oldStroke = g2d.getStroke();
float dash[] = {40.0f};
g2d.setStroke(
new BasicStroke(
4.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 0.0f, dash, 40.0f));
g2d.drawRoundRect(x, y, 320, 75, 20, 20);
g2d.setColor(Color.red);
g2d.drawString(String.format("New Highscore"), x + 20, y + 50);
g2d.rotate(.4, x, y);
g2d.setStroke(oldStroke);
g2d.setColor(Color.lightGray);
g2d.setFont(new Font("Courier", Font.PLAIN, 20));
g2d.drawString("Your record was " + oldHighScore + " kills", 210, 260);
} else if (cheated) {
int x = 20;
int y = 130;
g2d.rotate(-.4, x, y);
g2d.setFont(new Font("Comic Sans MS", Font.PLAIN, 40));
g2d.setColor(Color.black);
Stroke oldStroke = g2d.getStroke();
float dash[] = {40.0f};
g2d.setStroke(
new BasicStroke(
4.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 0.0f, dash, 40.0f));
g2d.drawRoundRect(x, y, 270, 75, 20, 20);
g2d.setColor(Color.red);
g2d.drawString(String.format("You cheated"), x + 20, y + 50);
g2d.rotate(.4, x, y);
g2d.setStroke(oldStroke);
g2d.setColor(Color.lightGray);
g2d.setFont(new Font("Courier", Font.PLAIN, 20));
g2d.drawString("Highscore not saved", 210, 260);
} else {
g2d.setColor(Color.lightGray);
g2d.setFont(new Font("Courier", Font.PLAIN, 20));
g2d.drawString("Your record is " + oldHighScore + " kills", 210, 260);
}
g2d.setColor(Color.black);
g2d.setFont(new Font("Courier", Font.PLAIN, 50));
if (player.score == 1) g2d.drawString(String.format(player.score + " kill"), 200, 230);
else g2d.drawString(String.format(player.score + " kills"), 200, 230);
g2d.setFont(new Font("Courier New", Font.PLAIN, 30));
g2d.setColor(Color.gray);
g2d.drawString(String.format("Press R to restart"), 150, 330);
return true;
}
if (window.isFocused() == false) paused = true;
if (paused) {
g2d.setColor(Color.white);
g2d.fill(new Rectangle(0, 0, width, height));
if (keyboard.keyDownOnce(KeyEvent.VK_ESCAPE)) paused = false;
g2d.setColor(Color.black);
g2d.setFont(new Font("Courier", Font.PLAIN, 50));
g2d.drawString("Paused", 200, 230);
g2d.setFont(new Font("Courier New", Font.PLAIN, 30));
g2d.setColor(Color.gray);
g2d.drawString(String.format("Press ESC to resume"), 150, 330);
return true;
}
return false;
}
/** Paints the text of the <tt>VisualEdge</tt>. */
public void paintText(Graphics2D g2d, Font font, Color fontColor, String text, float x, float y) {
g2d.setFont(font);
g2d.setColor(fontColor);
g2d.drawString(text, x, y);
}
public synchronized void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
Image water = Toolkit.getDefaultToolkit().getImage("catanui/water.jpg");
g.drawImage(water, 0, 0, this);
for (Hex o : _hexes) {
o.paint(g, _display_offset[0], _display_offset[1]);
}
g.translate(_display_offset[0] + 2, _display_offset[1] - 1);
synchronized (portContents) {
for (Pair c : portContents.keySet()) {
int lowx =
hexleft
+ (((CoordPair) c.getA()).getX() - (((CoordPair) c.getA()).getX() % 2))
/ 2
* intervalSide[0]
+ (((CoordPair) c.getA()).getX() - (((CoordPair) c.getA()).getX() % 2))
/ 2
* intervalSide[1]
+ (((CoordPair) c.getA()).getX() % 2) * intervalSide[0];
int lowy = hextop + ((CoordPair) c.getA()).getY() * intervalUp;
int highx =
hexleft
+ (((CoordPair) c.getB()).getX() - (((CoordPair) c.getB()).getX() % 2))
/ 2
* intervalSide[0]
+ (((CoordPair) c.getB()).getX() - (((CoordPair) c.getB()).getX() % 2))
/ 2
* intervalSide[1]
+ (((CoordPair) c.getB()).getX() % 2) * intervalSide[0];
int highy = hextop + ((CoordPair) c.getB()).getY() * intervalUp;
int dx = highx - lowx;
int dy = highy - lowy;
double rad = Math.atan((1.0) * dy / dx);
if (dx < 0) rad += Math.PI;
g.translate(lowx, lowy);
g.rotate(rad);
g.drawImage(
BoardObject.images.get(BoardObject.type2port.get(portContents.get(c))), 0, -75, null);
g.rotate(-rad);
g.translate((-1) * lowx, (-1) * lowy);
}
}
g.translate((-1) * _display_offset[0], (-1) * _display_offset[1]);
synchronized (roadContents) {
for (Pair c : roadContents.keySet()) {
Road r =
new Road(
hexleft
+ (((CoordPair) c.getA()).getX() - (((CoordPair) c.getA()).getX() % 2))
/ 2
* intervalSide[0]
+ (((CoordPair) c.getA()).getX() - (((CoordPair) c.getA()).getX() % 2))
/ 2
* intervalSide[1]
+ (((CoordPair) c.getA()).getX() % 2) * intervalSide[0],
hextop + ((CoordPair) c.getA()).getY() * intervalUp);
r.setX2(
hexleft
+ (((CoordPair) c.getB()).getX() - (((CoordPair) c.getB()).getX() % 2))
/ 2
* intervalSide[0]
+ (((CoordPair) c.getB()).getX() - (((CoordPair) c.getB()).getX() % 2))
/ 2
* intervalSide[1]
+ (((CoordPair) c.getB()).getX() % 2) * intervalSide[0]);
r.setY2(hextop + ((CoordPair) c.getB()).getY() * intervalUp);
r.setColor(roadContents.get(c));
r.paint(g, _display_offset[0], _display_offset[1]);
}
}
synchronized (vertexContents) {
for (CoordPair c : vertexContents.keySet()) {
int newx =
hexleft
+ ((c._x - (c._x % 2)) / 2 * intervalSide[0]
+ (c._x - (c._x % 2)) / 2 * intervalSide[1]
+ (c._x % 2) * intervalSide[0])
- 20;
int newy = hextop + c._y * intervalUp - 20;
if ((BoardObject.type) (vertexContents.get(c).getA()) == BoardObject.type.SETTLEMENT) {
Settlement s = new Settlement(newx, newy, (Integer) (vertexContents.get(c).getB()));
s.paint(g, _display_offset[0], _display_offset[1]);
} else if ((BoardObject.type) (vertexContents.get(c).getA()) == BoardObject.type.CITY) {
City s = new City(newx, newy, (Integer) (vertexContents.get(c).getB()));
s.paint(g, _display_offset[0], _display_offset[1]);
} else System.out.println("neither -_-");
}
}
g.setColor(Color.GRAY);
g.fill(new Rectangle(0, 0, 110, 60));
g.setColor(Color.LIGHT_GRAY);
g.fill(new Rectangle(3, 3, 104, 56));
if (_dieRoll > 0) {
BufferedImage r1img =
diceImage.getSubimage((int) (Math.floor((twoDice[0] - 1) * 94.7)), 0, 94, 93);
g.drawImage(r1img, 5, 7, 48, 47, null);
BufferedImage r2img =
diceImage.getSubimage((int) (Math.floor((twoDice[1] - 1) * 94.7)), 0, 94, 93);
g.drawImage(r2img, 55, 7, 48, 47, null);
}
if (_up != null) _up.paint(g);
if (!_gameOver.equals("") && !_dismiss) {
_currAlpha += 0.007;
}
g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, _currAlpha));
g.setColor(Color.GRAY);
g.fill(new Rectangle(-20, 0, 1020, 650));
g.setColor(Color.BLACK);
g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) 1.0));
if (!_gameOver.equals("")) {
if (_currAlpha >= 0.8) {
if (_gameOver.equals(gameLogic._name)) {
g.drawString("Congratulations, you won!", 350, 200);
} else {
g.drawString(_gameOver + " has won!", 350, 200);
}
_dismiss = true;
} else repaint();
}
}
// also clip, transform, composite,
// public boolean isOpaque(){return false;}//theOpaque!=null&&theOpaque;}
// ---------------------------------------------------------
private void doPaint(Graphics2D g, int s, Object o) {
// process an operation from the buffer
// System.out.println(s);
Object o1 = null,
o2 = null,
o3 = null,
o4 = null,
o5 = null,
o6 = null,
o7 = null,
o8 = null,
o9 = null,
o10 = null,
o11 = null;
if (o instanceof Object[]) {
Object[] a = (Object[]) o;
if (a.length > 0) o1 = a[0];
if (a.length > 1) o2 = a[1];
if (a.length > 2) o3 = a[2];
if (a.length > 3) o4 = a[3];
if (a.length > 4) o5 = a[4];
if (a.length > 5) o6 = a[5];
if (a.length > 6) o7 = a[6];
if (a.length > 7) o8 = a[7];
if (a.length > 8) o9 = a[8];
if (a.length > 9) o10 = a[9];
if (a.length > 10) o11 = a[10];
}
switch (s) {
case clear:
paintBackground(g, theBackground);
break;
// public void addRenderingHints(Map<?,?> hints)
// {toBuffer("addRenderingHints",hints );}
case addRenderingHints:
g.addRenderingHints((Map<?, ?>) o);
break;
case clip1:
g.clip((Shape) o);
break;
case draw1:
g.draw((Shape) o);
break;
case draw3DRect:
g.draw3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
break;
case drawGlyphVector:
g.drawGlyphVector((GlyphVector) o1, (Float) o2, (Float) o3);
break;
case drawImage1:
g.drawImage((BufferedImage) o1, (BufferedImageOp) o2, (Integer) o3, (Integer) o4);
break;
case drawImage2:
g.drawImage((Image) o1, (AffineTransform) o2, (ImageObserver) o3);
break;
case drawRenderableImage:
g.drawRenderableImage((RenderableImage) o1, (AffineTransform) o2);
break;
case drawRenderedImage:
g.drawRenderedImage((RenderedImage) o1, (AffineTransform) o2);
break;
case drawString1:
g.drawString((AttributedCharacterIterator) o1, (Float) o2, (Float) o3);
break;
case drawString2:
g.drawString((AttributedCharacterIterator) o1, (Integer) o2, (Integer) o3);
break;
case drawString3:
g.drawString((String) o1, (Float) o2, (Float) o3);
break;
case drawString4:
g.drawString((String) o1, (Integer) o2, (Integer) o3);
break;
case fill:
g.fill((Shape) o);
break;
case fill3DRect:
g.fill3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
break;
case rotate1:
g.rotate((Double) o);
break;
case rotate2:
g.rotate((Double) o1, (Double) o2, (Double) o3);
break;
case scale1:
g.scale((Double) o1, (Double) o2);
break;
case setBackground:
g.setBackground(
(Color) o); // paintBackground(g,(Color)o); /*super.setBackground((Color)o) ;*/
break;
case setComposite:
g.setComposite((Composite) o);
break;
case setPaint:
g.setPaint((Paint) o);
break;
case setRenderingHint:
g.setRenderingHint((RenderingHints.Key) o1, o2);
break;
case setRenderingHints:
g.setRenderingHints((Map<?, ?>) o);
break;
case setStroke:
g.setStroke((Stroke) o);
break;
case setTransform:
g.setTransform(makeTransform(o));
break;
case shear:
g.shear((Double) o1, (Double) o2);
break;
case transform1:
g.transform(makeTransform(o));
break;
case translate1:
g.translate((Double) o1, (Double) o2);
break;
case translate2:
g.translate((Integer) o1, (Integer) o2);
break;
case clearRect:
g.clearRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case copyArea:
g.copyArea(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case drawArc:
g.drawArc(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case drawBytes:
g.drawBytes((byte[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
break;
case drawChars:
g.drawChars((char[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
break;
case drawImage4:
g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (Color) o4, (ImageObserver) o5);
break;
case drawImage5:
g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (ImageObserver) o4);
break;
case drawImage6:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Color) o6,
(ImageObserver) o7);
break;
case drawImage7:
g.drawImage(
(Image) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (ImageObserver) o6);
break;
case drawImage8:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Integer) o6,
(Integer) o7,
(Integer) o8,
(Integer) o9,
(Color) o10,
(ImageObserver) o11);
break;
case drawImage9:
g.drawImage(
(Image) o1,
(Integer) o2,
(Integer) o3,
(Integer) o4,
(Integer) o5,
(Integer) o6,
(Integer) o7,
(Integer) o8,
(Integer) o9,
(ImageObserver) o10);
break;
case drawLine:
g.drawLine((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawOval:
g.drawOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawPolygon1:
g.drawPolygon((int[]) o1, (int[]) o2, (Integer) o3);
break;
case drawPolygon2:
g.drawPolygon((Polygon) o);
break;
case drawPolyline:
g.drawPolyline((int[]) o1, (int[]) o2, (Integer) o3);
break;
case drawRect:
g.drawRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case drawRoundRect:
g.drawRoundRect(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case fillArc:
g.fillArc(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case fillOval:
g.fillOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
// {toBuffer("fillPolygon",mkArg(xPoints, yPoints, nPoints) );}
case fillPolygon1:
g.fillPolygon((int[]) o1, (int[]) o2, (Integer) o3);
break;
case fillPolygon2:
g.fillPolygon((Polygon) o);
break;
case fillRect:
g.fillRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
break;
case fillRoundRect:
g.fillRoundRect(
(Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
break;
case setClip1:
g.setClip((Shape) o);
break;
case setColor:
g.setColor((Color) o);
break;
case setFont:
g.setFont((Font) o);
break;
case setPaintMode:
g.setPaintMode();
break;
case setXORMode:
g.setXORMode((Color) o);
break;
case opaque:
super.setOpaque((Boolean) o);
break;
case drawOutline: // g.drawString((String)o1, (Integer)o2, (Integer)o3) ;break;
{
FontRenderContext frc = g.getFontRenderContext();
TextLayout tl = new TextLayout((String) o1, g.getFont(), frc);
Shape s1 = tl.getOutline(null);
AffineTransform af = g.getTransform();
g.translate((Integer) o2, (Integer) o3);
g.draw(s1);
g.setTransform(af);
}
;
break;
default:
System.out.println("Unknown image operation " + s);
}
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
// g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);
Graphics2D canvas = (Graphics2D) g;
if (panelBackground != null) {
canvas.drawImage(panelBackground, 0, 0, getPanelWidth(), getPanelHeight(), null);
}
if (dalekDamageImage != null) {
// int w = 100;
// int h = (int) (dalekImage.getHeight(null) * w / dalekImage.getWidth(null) );
int h = 200;
// int w = dalekDamageImage.scaleWidth(h);
int w = h * dalekDamageImage.getWidth(null) / dalekDamageImage.getHeight(null);
BufferedImage thumbImage = new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
Graphics2D graphics2D = thumbImage.createGraphics();
graphics2D.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
graphics2D.drawImage(dalekDamageImage, 0, 0, w, h, null);
canvas.drawImage(thumbImage, getPanelWidth() / 2 - (w / 2), getPanelHeight() - h - 16, null);
// g.drawImage(thumbImage,getPanelWidth()/2 - (w/2), 32 ,null);
}
if (dalekTacticalImage != null) {
// int h = 400;
// int w = dalekTacticalImage.scaleWidth(h);
BufferedImage thumbImage =
new BufferedImage(
dalekTacticalImage.getWidth(),
dalekTacticalImage.getHeight(),
BufferedImage.TYPE_4BYTE_ABGR);
Graphics2D graphics2D = thumbImage.createGraphics();
graphics2D.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
graphics2D.drawImage(dalekTacticalImage, 0, 0, null);
// g.drawImage(thumbImage,getPanelWidth()/2 - (w/2), getPanelHeight() - h - 16 ,null);
canvas.drawImage(thumbImage, 0, 32, null);
/*
Iterator<WeaponUI> it = dalekTacticalImage.iterator();
int y = 32;
while (it.hasNext()) {
g.drawImage(it.next(),0, y ,null);
y += 40; // really want height of WeaponUI.
}
*/
}
// Move to Buffered Image
if (this.getEngineRun() > 0) {
this.drawEngineAt(
canvas, 16, 256, this.getEngineWalk(), this.getEngineRun(), this.getEngineCurrent());
}
if (this.name != null) {
canvas.setFont(techFont);
canvas.drawString(this.name, 16, 24);
}
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// x-axis
g2.drawLine(X_AXIS_FIRST_X_COORD, X_AXIS_Y_COORD, X_AXIS_SECOND_X_COORD, X_AXIS_Y_COORD);
// y-axis
g2.drawLine(Y_AXIS_X_COORD, Y_AXIS_FIRST_Y_COORD, Y_AXIS_X_COORD, Y_AXIS_SECOND_Y_COORD);
// // x-axis arrow
g2.drawLine(
X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
X_AXIS_Y_COORD - SECOND_LENGHT,
X_AXIS_SECOND_X_COORD,
X_AXIS_Y_COORD);
g2.drawLine(
X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
X_AXIS_Y_COORD + SECOND_LENGHT,
X_AXIS_SECOND_X_COORD,
X_AXIS_Y_COORD);
// // y-axis arrow
g2.drawLine(
Y_AXIS_X_COORD - SECOND_LENGHT,
Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
Y_AXIS_X_COORD,
Y_AXIS_FIRST_Y_COORD);
g2.drawLine(
Y_AXIS_X_COORD + SECOND_LENGHT,
Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
Y_AXIS_X_COORD,
Y_AXIS_FIRST_Y_COORD);
// // draw origin Point
g2.fillOval(
X_AXIS_FIRST_X_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
Y_AXIS_SECOND_Y_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
ORIGIN_COORDINATE_LENGHT,
ORIGIN_COORDINATE_LENGHT);
// draw text "X" and draw text "Y"
g2.drawString(
"X",
X_AXIS_SECOND_X_COORD - AXIS_STRING_DISTANCE / 2,
X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
g2.drawString(
"Y",
Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
Y_AXIS_FIRST_Y_COORD + AXIS_STRING_DISTANCE / 2);
g2.drawString(
"(0, 0)",
X_AXIS_FIRST_X_COORD - AXIS_STRING_DISTANCE,
Y_AXIS_SECOND_Y_COORD + AXIS_STRING_DISTANCE);
// numerate axis
int xLength = (X_AXIS_SECOND_X_COORD - X_AXIS_FIRST_X_COORD) / xCoordNumbers;
int yLength = (Y_AXIS_SECOND_Y_COORD - Y_AXIS_FIRST_Y_COORD) / yCoordNumbers;
// draw x-axis numbers
for (int i = 1; i < xCoordNumbers; i++) {
g2.drawLine(
X_AXIS_FIRST_X_COORD + (i * xLength),
X_AXIS_Y_COORD - SECOND_LENGHT,
X_AXIS_FIRST_X_COORD + (i * xLength),
X_AXIS_Y_COORD + SECOND_LENGHT);
g2.drawString(
Integer.toString(i),
X_AXIS_FIRST_X_COORD + (i * xLength) - 3,
X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
}
// //draw y-axis numbers
for (int i = 1; i < yCoordNumbers; i++) {
g2.drawLine(
Y_AXIS_X_COORD - SECOND_LENGHT,
Y_AXIS_SECOND_Y_COORD - (i * yLength),
Y_AXIS_X_COORD + SECOND_LENGHT,
Y_AXIS_SECOND_Y_COORD - (i * yLength));
g2.drawString(
"0," + Integer.toString(i),
Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
Y_AXIS_SECOND_Y_COORD - (i * yLength));
}
for (int i = 0; i < jumlahGrafik; i++) {
doDrawing(g, this.std[i], this.sig[i], i);
}
for (int i = 0; i < jumlahGrafik; i++) {
alpaCut(g, this.alfa, i);
}
}
void draw(Graphics2D g) {
int endX, endY;
Block from = null;
if (fromId > -1) from = diag.blocks.get(new Integer(fromId));
Block to = null;
if (!endsAtLine && toId > -1) to = diag.blocks.get(new Integer(toId));
if (toX == -1) endX = diag.xa;
else endX = toX;
if (toY == -1) endY = diag.ya;
else endY = toY;
g.setColor(Color.GRAY);
Stroke stroke = g.getStroke();
ZigzagStroke zzstroke = new ZigzagStroke(stroke, 2, 4);
if (toX == -1) {
g.drawRect(fromX - 3, fromY - 3, 6, 6);
return;
}
if (from != null) {
if (fromSide == Side.TOP) fromY = from.cy - from.height / 2;
else if (fromSide == Side.BOTTOM) fromY = from.cy + from.height / 2;
else if (fromSide == Side.LEFT) fromX = from.cx - from.width / 2;
else if (fromSide == Side.RIGHT) fromX = from.cx + from.width / 2;
}
if (to != null) {
if (toSide == Side.TOP) toY = to.cy - to.height / 2;
else if (toSide == Side.BOTTOM) toY = to.cy + to.height / 2;
else if (toSide == Side.LEFT) toX = to.cx - to.width / 2;
else if (toSide == Side.RIGHT) toX = to.cx + to.width / 2;
}
if (driver.selArrowP == this) g.setColor(Color.BLUE);
else if ((from instanceof ComponentBlock
|| from instanceof ExtPortBlock
|| from instanceof Enclosure)
&& (to instanceof ComponentBlock
|| to instanceof ExtPortBlock
|| to instanceof Enclosure
|| endsAtLine))
if (checkStatus == Status.UNCHECKED) g.setColor(Color.BLACK);
else if (checkStatus == Status.COMPATIBLE) g.setColor(FOREST_GREEN);
else g.setColor(ORANGE_RED);
else if (from instanceof LegendBlock || to instanceof LegendBlock) g.setColor(Color.GRAY);
int fx, fy, tx, ty;
fx = fromX;
fy = fromY;
// tx = toX;
// ty = toY;
// int autoX = -1, autoY = -1; // only used for automatic ports
if (bends != null) {
for (Bend bend : bends) {
tx = bend.x;
ty = bend.y;
if (!dropOldest) g.drawLine(fx, fy, tx, ty);
else {
Shape shape = new Line2D.Double(fx, fy, tx, ty);
shape = zzstroke.createStrokedShape(shape);
g.draw(shape);
// g.setStroke(stroke);
}
if (bend.marked) {
Color col = g.getColor();
g.setColor(Color.RED);
g.drawOval(tx - 5, ty - 5, 10, 10);
g.setColor(col);
}
calcLimits(fx, tx, fy, ty);
fx = tx;
fy = ty;
}
}
tx = endX;
ty = endY;
int x = endX;
if (to != null && endsAtBlock && to.multiplex) {
String s = to.mpxfactor;
if (s == null) s = " ";
int i = s.length() * driver.fontWidth + 10;
x -= i;
}
if (headMarked) {
Color col = g.getColor();
g.setColor(Color.RED);
g.drawOval(x - 5, toY - 5, 10, 10);
g.setColor(col);
}
if (!dropOldest) g.drawLine(fx, fy, tx, ty);
else {
Shape shape = new Line2D.Double(fx, fy, tx, ty);
shape = zzstroke.createStrokedShape(shape);
g.draw(shape);
// g.setStroke(stroke);
}
if (tailMarked) {
Color col = g.getColor();
g.setColor(Color.RED);
g.drawOval(fromX - 5, fromY - 5, 10, 10);
g.setColor(col);
}
calcLimits(fx, x, fy, toY);
if (!endsAtBlock && !endsAtLine) {
g.drawRect(fromX - 3, fromY - 3, 6, 6);
g.drawRect(x - 3, toY - 3, 6, 6);
} else if (endsAtBlock) {
if ((from instanceof ComponentBlock
|| from instanceof ExtPortBlock
|| from instanceof Enclosure)
&& (to instanceof ComponentBlock
|| to instanceof ExtPortBlock
|| to instanceof Enclosure)) {
Arrowhead ah = new Arrowhead(fx, fy, toX, toY);
ah.draw(g);
}
} else if (endsAtLine) {
drawCircleTo(g, fx, fy, x, toY, Color.BLACK, 4);
// g.drawOval(toX - 2, toY - 2, 4, 4);
// g.fillOval(toX - 2, toY - 2, 4, 4);
}
if (toX != -1 && (endsAtBlock || endsAtLine)) {
if (upStreamPort != null && (from instanceof ComponentBlock || from instanceof Enclosure)) {
if (upStreamPort.equals("*")) {
drawCircleFrom(g, fromX, fromY, endX, endY, Color.BLUE, 8);
// g.setColor(Color.BLUE);
// g.drawOval(fromX, fromY - 4, 8, 8);
// g.fillOval(fromX, fromY - 4, 8, 8);
} else if (from.visible) {
g.setColor(Color.BLUE);
int y = fromY + driver.fontHeight;
int x2 = fromX + driver.fontWidth;
g.drawString(upStreamPort, x2, y);
}
g.setColor(Color.BLACK);
}
if (downStreamPort != null
&& !endsAtLine
&& to != null
&& (to instanceof ComponentBlock || to instanceof Enclosure)) {
if (downStreamPort.equals("*")) {
drawCircleTo(g, fx, fy, toX, toY, Color.BLUE, 8);
// g.setColor(Color.BLUE);
// g.drawOval(x - 8, toY - 4, 8, 8);
// g.fillOval(x - 8, toY - 4, 8, 8);
} else if (to.visible) {
g.setColor(Color.BLUE);
int y = toY - driver.fontHeight / 2;
x = toX - driver.fontWidth * (downStreamPort.length() + 1);
if (!endsAtLine && to != null && to.multiplex) x -= 20;
g.drawString(downStreamPort, x, y);
}
g.setColor(Color.BLACK);
}
}
if (extraArrowhead != null) extraArrowhead.draw(g);
}
public void paintRegion(Graphics2D g, int x1, int y1, int w, int h) {
int h2 = h / 2;
int rad = 3;
int diam = rad * 2;
Color lg = Color.cyan;
Color dg = Color.orange;
lg = new Color(lg.getRed(), lg.getGreen(), lg.getBlue(), 75);
dg = new Color(dg.getRed(), dg.getGreen(), dg.getBlue(), 75);
/*
* Draw the Baseline
*/
g.setColor(Color.black);
g.drawLine(x1, y1 + h, x1 + w, y1 + h);
Stroke oldStroke = g.getStroke();
g.setStroke(new BasicStroke((float) 2.0));
/*
* Draw the datapoints
*/
for (ExprPoint ep : points) {
if (ep.strand == '+') {
g.setColor(lg);
} else {
g.setColor(dg);
}
g.drawOval(x1 + ep.x - rad, y1 + ep.y - rad, diam, diam);
}
g.setStroke(oldStroke);
/*
* Paint the hash marks...
*/
if (!displayOppositeChannel) {
g.setColor(Color.black);
boolean flipper = true;
for (int value = 100;
value <= scale.getMax();
value *= (flipper ? 5 : 2), flipper = !flipper) {
int yoff = getYOffset((double) value);
String line = String.format("%d", value);
int uy = y1 + h2 - yoff, ly = y1 + h2 + yoff;
g.drawLine(x1, uy, x1 + 10, uy);
g.drawString(line, x1 + 12, uy + 5);
g.drawLine(x1, ly, x1 + 10, ly);
g.drawString(line, x1 + 12, ly + 5);
}
}
/*
* Draw any selections.
*/
g.setColor(Color.black);
for (Point p : selections.keySet()) {
ExprPoint ep = selections.get(p);
g.drawLine(p.x, p.y, ep.x, ep.y);
g.drawString(ep.getLabel(), p.x, p.y);
}
/*
* Draw the label in the upper-right hand corner.
*/
g.setColor(Color.black);
Font oldFont = g.getFont();
Font newFont = new Font("Arial", Font.BOLD, 24);
g.setFont(newFont);
FontMetrics fm = g.getFontMetrics();
int lblHeight = fm.getAscent() + fm.getDescent();
int lblWidth = fm.charsWidth(label.toCharArray(), 0, label.length());
int padding = 5;
int lblx = x1 + w - lblWidth - padding;
int lbly = y1 + lblHeight + padding;
g.drawString(label, lblx, lbly);
g.setFont(oldFont);
}
