Esempio n. 1
0
  public void paintBoard(Graphics2D g2) {

    double gbwidth = boardGridSize * 8d + lineLoc, gbheight = boardGridSize * 9d + lineLoc;
    g2.setPaint(red);
    g2.draw3DRect((int) lineLoc / 2, (int) lineLoc / 2, (int) gbwidth, (int) gbheight, true);
    g2.draw3DRect(
        (int) lineLoc / 2 + 3, (int) lineLoc / 2 + 3, (int) gbwidth - 6, (int) gbheight - 7, false);
    g2.setPaint(fg);
    for (int i = 0; i < 10; i++) {
      g2.draw(
          new Line2D.Double(
              lineLoc,
              lineLoc + boardGridSize * i,
              lineLoc + boardGridSize * 8,
              lineLoc + boardGridSize * i));
    }
    for (int i = 0; i < 9; i++) {
      g2.draw(
          new Line2D.Double(
              lineLoc + boardGridSize * i,
              lineLoc,
              lineLoc + boardGridSize * i,
              lineLoc + boardGridSize * 4));
      if (i == 0 || i == 8)
        g2.draw(
            new Line2D.Double(
                lineLoc + boardGridSize * i,
                lineLoc + boardGridSize * 4,
                lineLoc + boardGridSize * i,
                lineLoc + boardGridSize * 9));
      else
        g2.draw(
            new Line2D.Double(
                lineLoc + boardGridSize * i,
                lineLoc + boardGridSize * 5,
                lineLoc + boardGridSize * i,
                lineLoc + boardGridSize * 9));
    }
    drawX(lineLoc + boardGridSize * 4, lineLoc + boardGridSize, g2);
    drawX(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 8, g2);
    // black Pao
    drawLocation(lineLoc + boardGridSize, lineLoc + boardGridSize * 2, center, g2);
    drawLocation(lineLoc + boardGridSize * 7, lineLoc + boardGridSize * 2, center, g2);
    // red Pao
    drawLocation(lineLoc + boardGridSize, lineLoc + boardGridSize * 7, center, g2);
    drawLocation(lineLoc + boardGridSize * 7, lineLoc + boardGridSize * 7, center, g2);
    // black Zu
    drawLocation(lineLoc, lineLoc + boardGridSize * 3, right, g2);
    drawLocation(lineLoc + boardGridSize * 2, lineLoc + boardGridSize * 3, center, g2);
    drawLocation(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 3, center, g2);
    drawLocation(lineLoc + boardGridSize * 6, lineLoc + boardGridSize * 3, center, g2);
    drawLocation(lineLoc + boardGridSize * 8, lineLoc + boardGridSize * 3, left, g2);
    // red bin
    drawLocation(lineLoc, lineLoc + boardGridSize * 6, right, g2);
    drawLocation(lineLoc + boardGridSize * 2, lineLoc + boardGridSize * 6, center, g2);
    drawLocation(lineLoc + boardGridSize * 4, lineLoc + boardGridSize * 6, center, g2);
    drawLocation(lineLoc + boardGridSize * 6, lineLoc + boardGridSize * 6, center, g2);
    drawLocation(lineLoc + boardGridSize * 8, lineLoc + boardGridSize * 6, left, g2);
    // ----------------------------------------------------------------------
  }
  /**
   * 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);
  }
Esempio n. 3
0
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;

    currentX = leftMargin;
    currentY = topMargin;

    // Draw the links

    for (int i = 0; i < linkLines.length; i++) {
      if (weights[i].isActive()) {
        g2.setPaint(weights[i].getColor());
        g2.draw(linkLines[i]);
      }
    }

    g2.setPaint(Color.black);

    // Draw the input neurons
    g2.drawString("Inputs", (float) currentX, (float) currentY);
    currentY += titleSpace;

    for (int i = 0; i < genome.getInputs(); i++) {
      g2.drawImage(inputNeuron, (int) currentX, (int) currentY, null);
      currentY += space;
    }

    // Draw the hidden Neurons
    currentX += space;
    currentY = topMargin;
    g2.drawString("Hidden Layers", (float) currentX, (float) currentY);

    for (int i = 0; i < genome.getHiddenLayers(); i++) {
      currentY = topMargin + titleSpace;
      for (int j = 0; j < genome.getNeuronsInHiddenLayer(); j++) {
        g2.drawImage(hiddenNeuron, (int) currentX, (int) currentY, null);
        currentY += space;
      }
      currentX += space;
    }

    // Draw the output neurons
    currentY = topMargin;
    g2.drawString("Outputs", (float) currentX, (float) currentY);
    currentY += titleSpace;

    for (int i = 0; i < genome.getOutputs(); i++) {
      g2.drawImage(outputNeuron, (int) currentX, (int) currentY, null);
      currentY += space;
    }

    // Draw the links

    for (int i = 0; i < linkLines.length; i++) {
      if (weights[i].isActive()) {
        g2.setPaint(weights[i].getColor());
        g2.draw(linkLines[i]);
      }
    }
  }
Esempio n. 4
0
  /**
   * Render the View to the given graphic context. This implementation render the interior first,
   * then the outline.
   */
  public void paint(Graphics2D g, Rectangle2D a) {
    if (!a.intersects(getBounds())) return;
    if (image != null) { // paint bitmap
      g.drawImage(image, text2ModelTr, null);
      // debug:
      g.setPaint(Color.red);
      g.draw(this.bounds);
      super.paint(g, a); // possibly paint framebox if non-null
    } else { // paint textlayout
      super.paint(g, a); // possibly paint framebox if non-null

      AffineTransform oldAT = g.getTransform();
      // paint text in black
      g.setPaint(Color.black);
      // from now on, we work in Y-direct (<0) coordinates to avoid inextricable problems with font
      // being mirrored...
      g.transform(text2ModelTr); // also include rotation
      textLayout.draw(g, 0.0f, 0.0f);
      // [pending] ajouter un cadre si areDimensionsComputed (wysiwyg du pauvre)
      // get back to previous transform
      g.setTransform(oldAT);
      if (DEBUG) {
        g.setPaint(Color.red);
        g.draw(bounds);
      }
    }
  }
Esempio n. 5
0
  /**
   * Paints the icon.
   *
   * @param c the component on which it is painted
   * @param _g the graphics context
   * @param x the x coordinate of the icon
   * @param y the y coordinate of the icon
   */
  public void paintIcon(Component c, Graphics _g, int x, int y) {
    Graphics2D g = (Graphics2D) _g;
    AffineTransform at = AffineTransform.getTranslateInstance(x + offsetX, y + offsetY);

    // save current graphics paint and clip
    Paint gPaint = g.getPaint();
    Shape gClip = g.getClip();

    // render shape(s)
    g.setPaint(color);
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g.clipRect(x, y, w, h);

    // paint shape, if any
    if (shape != null) {
      g.fill(at.createTransformedShape(shape));
    }

    // paint decoration, if any
    if (decoration != null) {
      g.setPaint(decoColor);
      g.fill(at.createTransformedShape(decoration));
    }
    // restore graphics paint and clip
    g.setPaint(gPaint);
    g.setClip(gClip);
  }
 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);
   }
 }
Esempio n. 7
0
  /** This method is invoked before the rendered image of the figure is composited. */
  public void drawFigure(Graphics2D g) {
    AffineTransform savedTransform = null;
    if (get(TRANSFORM) != null) {
      savedTransform = g.getTransform();
      g.transform(get(TRANSFORM));
    }

    if (get(FILL_STYLE) != ODGConstants.FillStyle.NONE) {
      Paint paint = ODGAttributeKeys.getFillPaint(this);
      if (paint != null) {
        g.setPaint(paint);
        drawFill(g);
      }
    }

    if (get(STROKE_STYLE) != ODGConstants.StrokeStyle.NONE) {
      Paint paint = ODGAttributeKeys.getStrokePaint(this);
      if (paint != null) {
        g.setPaint(paint);
        g.setStroke(ODGAttributeKeys.getStroke(this));
        drawStroke(g);
      }
    }
    if (get(TRANSFORM) != null) {
      g.setTransform(savedTransform);
    }
  }
Esempio n. 8
0
 public void paintComponent(Graphics g) {
   Graphics2D g2 = (Graphics2D) g;
   Rectangle2D rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1);
   g2.setPaint(Color.YELLOW);
   g2.fill(rect);
   g2.setPaint(Color.BLUE);
   g2.draw(rect);
 }
Esempio n. 9
0
    public void draw(Graphics2D g2) {
      g2.setPaint(selected ? selColor : bgColor);
      g2.fill(rect);
      // g2.fill(new Rectangle2D.Double(row,col,10,10));
      // g2.fill(new Rectangle2D.Double(rect.x,rect.y,rect.height, rect.width));
      g2.setPaint(color);

      g2.draw(rect);
    }
Esempio n. 10
0
 @Override
 public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
   Graphics2D g2 = (Graphics2D) g.create();
   g2.translate(x, y);
   g2.setPaint(borderSelectionColor);
   g2.drawRect(0, 0, w - 1, h - 1);
   g2.setPaint(getLineColor());
   BasicGraphicsUtils.drawDashedRect(g2, 0, 0, w, h);
   g2.dispose();
 }
Esempio n. 11
0
  @Override
  protected BufferedImage renderOffscreen() {
    BufferedImage bimage = null;

    if (getOrientation() == SwingConstants.HORIZONTAL) {

      bimage = new BufferedImage(DEFAULT_WIDTH, 10, BufferedImage.TYPE_4BYTE_ABGR);
      Graphics2D g2d = bimage.createGraphics();
      int ncolors = colorMap.getMapSize();
      double distance = colorMap.getMaximumValue() - colorMap.getMinimumValue();

      double start = colorMap.getMinimumValue();

      for (int i = 0; i < ncolors; i++) {
        ColorInterval ci = colorMap.getInterval(i);
        double size = ((ci.getMaximum() - ci.getMinimum()) / distance);
        double xpos = (ci.getMinimum() - start) / distance;

        Rectangle2D rect =
            new Rectangle2D.Double(xpos * DEFAULT_WIDTH, 0, size * DEFAULT_WIDTH, 10);
        float trans = (float) ci.getAlpha();

        AlphaComposite comp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trans / 255f);

        g2d.setComposite(comp);
        g2d.setPaint(ci.getColor());
        g2d.fill(rect);
      }
    } else {
      bimage = new BufferedImage(10, DEFAULT_HEIGHT, BufferedImage.TYPE_4BYTE_ABGR);
      int ncolors = colorMap.getMapSize();
      double distance = colorMap.getMaximumValue() - colorMap.getMinimumValue();
      double start = colorMap.getMinimumValue();

      Graphics2D g2d = bimage.createGraphics();
      for (int i = 0; i < ncolors; i++) {
        ColorInterval ci = colorMap.getInterval(i);
        double size = ((ci.getMaximum() - ci.getMinimum()) / distance);
        double ypos = (ci.getMinimum() - start) / distance;

        Rectangle2D rect =
            new Rectangle2D.Double(0, ypos * DEFAULT_HEIGHT, 10, size * DEFAULT_HEIGHT);
        float trans = (float) ci.getAlpha();

        AlphaComposite comp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trans / 255f);

        g2d.setComposite(comp);
        g2d.setPaint(ci.getColor());
        g2d.fill(rect);
      }
    }

    cachedImage = bimage;
    return cachedImage;
  }
Esempio n. 12
0
 private void paintBackgroundPressedAndDefault(Graphics2D g) {
   roundRect = decodeRoundRect1();
   g.setPaint(color17);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient4(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient2(roundRect));
   g.fill(roundRect);
 }
Esempio n. 13
0
 private void paintBackgroundMouseOverAndDefault(Graphics2D g) {
   roundRect = decodeRoundRect5();
   g.setPaint(color1);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient3(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient2(roundRect));
   g.fill(roundRect);
 }
Esempio n. 14
0
 private void paintBackgroundEnabled(Graphics2D g) {
   roundRect = decodeRoundRect1();
   g.setPaint(color1);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient7(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient2(roundRect));
   g.fill(roundRect);
 }
Esempio n. 15
0
 private void paintBackgroundPressedAndFocused(Graphics2D g) {
   roundRect = decodeRoundRect4();
   g.setPaint(color9);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient11(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient2(roundRect));
   g.fill(roundRect);
 }
Esempio n. 16
0
 private void paintBackgroundDisabled(Graphics2D g) {
   roundRect = decodeRoundRect1();
   g.setPaint(color25);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient5(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient6(roundRect));
   g.fill(roundRect);
 }
Esempio n. 17
0
 private void paintBackgroundMouseOverAndFocused(Graphics2D g) {
   roundRect = decodeRoundRect4();
   g.setPaint(color9);
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient9(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect3();
   g.setPaint(decodeGradient10(roundRect));
   g.fill(roundRect);
 }
Esempio n. 18
0
  /**
   * Paints background and children.
   *
   * @param g context.
   */
  public void paint(Graphics g) {
    // Paint background
    int width = getSize().width;
    int height = getSize().height;

    Graphics2D g2 = (Graphics2D) g;
    Paint storedPaint = g2.getPaint();
    g2.setPaint(new GradientPaint(0, 0, backgroundColor1, 0, height, backgroundColor2));
    g2.fillRect(0, 0, width, height);
    g2.setPaint(storedPaint);

    paintChildren(g);
  }
Esempio n. 19
0
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    int w = getWidth();
    int h = getHeight();
    double theta, x, y;

    g2.setPaint(Color.blue);
    double x1 = w * 3 / 24, y1 = h * 3 / 32, x2 = w * 11 / 24, y2 = y1;
    g2.draw(new Line2D.Double(x1, y1, x2, y2));
    // draw this arrow head at point x2, y2 and measure
    // angle theta relative to same point, ie, y2 - and x2 -
    theta = Math.atan2(y2 - y1, x2 - x1);
    drawArrow(g2, theta, x2, y2);

    x1 = w * 3 / 8;
    y1 = h * 13 / 15;
    x2 = w * 2 / 3;
    y2 = y1;
    g2.draw(new Line2D.Double(x1, y1, x2, y2));
    theta = Math.atan2(y1 - y2, x1 - x2);
    drawArrow(g2, theta, x1, y1);

    g2.setPaint(Color.red);
    x1 = w * 3 / 24;
    y1 = h * 4 / 32;
    x2 = x1;
    y2 = h * 18 / 32;
    g2.draw(new Line2D.Double(x1, y1, x2, y2));
    theta = Math.atan2(y2 - y1, x2 - x1);
    drawArrow(g2, theta, x2, y2);

    g2.setPaint(Color.orange);
    x1 = w * 5 / 32;
    y1 = h * 27 / 32;
    x2 = w * 27 / 32;
    y2 = h * 5 / 32;
    g2.draw(new Line2D.Double(x1, y1, x2, y2));
    theta = Math.atan2(y2 - y1, x2 - x1);
    drawArrow(g2, theta, x2, y2);

    g2.setPaint(Color.green.darker());
    x1 = w / 2;
    y1 = h / 2;
    x2 = w * 27 / 32;
    y2 = h * 27 / 32;
    g2.draw(new Line2D.Double(x1, y1, x2, y2));
    theta = Math.atan2(y2 - y1, x2 - x1);
    drawArrow(g2, theta, x2, y2);
  }
 protected void paintComponent(Graphics g) {
   super.paintComponent(g);
   Graphics2D g2 = (Graphics2D) g;
   g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   int w = getWidth();
   int h = getHeight();
   // Draw ordinate.
   g2.draw(new Line2D.Double(Points, Points, Points, h - Points));
   // Draw abcissa.
   g2.draw(new Line2D.Double(Points, h - Points, w - Points, h - Points));
   // Draw labels.
   Font font = g2.getFont();
   FontRenderContext frc = g2.getFontRenderContext();
   LineMetrics lm = font.getLineMetrics("0", frc);
   float sh = lm.getAscent() + lm.getDescent();
   // Ordinate label.
   String s = "Strecke";
   float sy = Points + ((h - 2 * Points) - s.length() * sh) / 2 + lm.getAscent();
   for (int i = 0; i < s.length(); i++) {
     String letter = String.valueOf(s.charAt(i));
     float sw = (float) font.getStringBounds(letter, frc).getWidth();
     float sx = (Points - sw) / 2;
     g2.drawString(letter, sx, sy);
     sy += sh;
   }
   // Abcissa label.
   s = "Datum";
   sy = h - Points + (Points - sh) / 2 + lm.getAscent();
   float sw = (float) font.getStringBounds(s, frc).getWidth();
   float sx = (w - sw) / 2;
   g2.drawString(s, sx, sy);
   // Draw lines.
   double xInc = (double) (w - 2 * Points) / (data.length - 1);
   double scale = (double) (h - 2 * Points) / getMax();
   g2.setPaint(Color.green.darker());
   for (int i = 0; i < data.length - 1; i++) {
     double x1 = Points + i * xInc;
     double y1 = h - Points - scale * data[i];
     double x2 = Points + (i + 1) * xInc;
     double y2 = h - Points - scale * data[i + 1];
     g2.draw(new Line2D.Double(x1, y1, x2, y2));
   }
   // Mark data points.
   g2.setPaint(Color.red);
   for (int i = 0; i < data.length; i++) {
     double x = Points + i * xInc;
     double y = h - Points - scale * data[i];
     g2.fill(new Ellipse2D.Double(x - 2, y - 2, 4, 4));
   }
 }
Esempio n. 21
0
 public void paint(Graphics g, Shape a) {
   Graphics2D g2 = (Graphics2D) g;
   Rectangle2D abounds = a.getBounds2D();
   AffineTransform saveTransform = g2.getTransform();
   Paint savePaint = g2.getPaint();
   try {
     g2.translate(abounds.getX() - bounds.getX(), abounds.getY() - bounds.getY());
     g2.setPaint(Color.BLACK); // FIXME
     p.paint(g2);
   } finally {
     g2.setTransform(saveTransform);
     g2.setPaint(savePaint);
   }
 }
Esempio n. 22
0
 public void paintComponent(Graphics g) {
   super.paintComponent(g);
   Graphics2D g2 = (Graphics2D) g;
   g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   Dimension d = getSize();
   Color fg3D = Color.lightGray;
   g2.setPaint(fg3D);
   g2.draw3DRect(0, 0, d.width - 1, d.height - 1, true);
   g2.draw3DRect(3, 3, d.width - 7, d.height - 7, false);
   g2.setPaint(fg);
   test.setBounds(boardGridSize * 4 + 10, boardGridSize * 5 - 20, 100, 50);
   this.add(test);
   paintBoard(g2);
 }
 private void paintBackgroundEnabledAndWindowNotFocusedAndWindowMaximized(Graphics2D g) {
   roundRect = decodeRoundRect1();
   g.setPaint(decodeGradient10(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient11(roundRect));
   g.fill(roundRect);
   rect = decodeRect1();
   g.setPaint(color4);
   g.fill(rect);
   rect = decodeRect4();
   g.setPaint(color54);
   g.fill(rect);
   rect = decodeRect5();
   g.setPaint(color55);
   g.fill(rect);
   rect = decodeRect8();
   g.setPaint(color56);
   g.fill(rect);
   path = decodePath1();
   g.setPaint(color57);
   g.fill(path);
   path = decodePath2();
   g.setPaint(color58);
   g.fill(path);
 }
 private void paintBackgroundEnabledAndWindowNotFocused(Graphics2D g) {
   roundRect = decodeRoundRect1();
   g.setPaint(decodeGradient10(roundRect));
   g.fill(roundRect);
   roundRect = decodeRoundRect2();
   g.setPaint(decodeGradient16(roundRect));
   g.fill(roundRect);
   rect = decodeRect1();
   g.setPaint(color4);
   g.fill(rect);
   path = decodePath4();
   g.setPaint(color72);
   g.fill(path);
 }
Esempio n. 25
0
 /** the paintComponent -- paints the board every repaint() call. */
 public void paintComponent(Graphics g) {
   super.paintComponent(g);
   Graphics2D g2 = (Graphics2D) g;
   for (int i = 0; i < B_WIDTH; i++) {
     for (int j = 0; j < B_HEIGHT; j++) {
       Rectangle2D rect = new Rectangle2D.Double((i * 40) + 1, (j * 40) + 1, 38, 38);
       g2.setPaint(balls[i][j].getColor());
       g2.fill(rect);
       Ellipse2D circle = new Ellipse2D.Double();
       circle.setFrame(rect);
       g2.setPaint(balls[i][j].getcColor());
       g2.fill(circle);
     }
   }
 }
Esempio n. 26
0
  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;
  }
Esempio n. 27
0
 /** Draws the edge structure of the tree */
 public void drawEdges(Graphics2D gg) {
   gg.setPaint(Color.black);
   Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
   // For each vertex...
   while (nodeList.hasMoreElements()) {
     // Get its edge list...
     TreeVertex vertex = (TreeVertex) nodeList.nextElement();
     Enumeration edges = vertex.getEdgeList().elements();
     // For each edge in the list...
     while (edges.hasMoreElements()) {
       TreeEdge edge = (TreeEdge) edges.nextElement();
       // If we have several vertices on layer 0, only draw
       // edges for layers below that
       if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) {
         // If the edge has been selected with the mouse,
         // use a thick line
         if (edge.isSelected()) {
           gg.setStroke(selectStroke);
         }
         gg.draw(edge.getShape(this));
         // If we used a thick line, reset the stroke to normal
         // line for next edge.
         if (edge.isSelected()) {
           gg.setStroke(solidStroke);
         }
         TreeVertex edgeSource = edge.getDestVertex();
       }
     }
   }
 }
  @Override
  protected void paintIcon(JComponent c, Graphics2D g, Rectangle viewRect, Rectangle iconRect) {
    int rad = JBUI.scale(4);

    // Paint the radio button
    final int x = iconRect.x + (rad - (rad % 2 == 1 ? 1 : 0)) / 2;
    final int y = iconRect.y + (rad - (rad % 2 == 1 ? 1 : 0)) / 2;
    final int w = iconRect.width - rad;
    final int h = iconRect.height - rad;
    final boolean enabled = c.isEnabled();
    Color color = enabled ? Gray.x50 : Gray.xD3;
    g.translate(x, y);
    // setup AA for lines
    final GraphicsConfig config = GraphicsUtil.setupAAPainting(g);
    g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
    final boolean selected = ((AbstractButton) c).isSelected();
    g.setPaint(color);
    g.drawOval(0, 0, w, h);

    if (selected) {
      g.setColor(color);
      g.fillOval(JBUI.scale(3), JBUI.scale(3), w - 2 * JBUI.scale(3), h - 2 * JBUI.scale(3));
    }
    config.restore();
    g.translate(-x, -y);
  }
Esempio n. 29
0
  //	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();
    }
  }
Esempio n. 30
0
  public void paintComponent(Graphics g) {

    GradientPaint gradient = new GradientPaint(70, 70, Color.blue, 150, 150, Color.orange);
    Image image = new ImageIcon("a.jpg").getImage();
    Random generator = new Random();

    int x1 = generator.nextInt(200) + 1;
    int y1 = generator.nextInt(200) + 1;
    int x2 = x1 + generator.nextInt(100) + 1;
    int y2 = x1 + generator.nextInt(100) + 1;

    g.setColor(Color.blue);
    g.fillRect(70, 70, 200, 100);

    g.setColor(Color.black);
    g.fillOval(80, 80, 170, 70);

    Graphics2D g2d = (Graphics2D) g;

    g.setColor(Color.yellow);
    g2d.fill3DRect(10, 10, 100, 100, true);

    g.drawImage(image, 300, 300, this);

    g2d.setPaint(gradient);
    g2d.fillOval(x1, y1, x2, y2);
  }