示例#1
0
    private void paintToImage(
        final BufferedImage img, final int x, final int y, final int width, final int height) {
      // clear the prior image
      Graphics2D imgG = (Graphics2D) img.getGraphics();
      imgG.setComposite(AlphaComposite.Clear);
      imgG.setColor(Color.black);
      imgG.fillRect(0, 0, width + blur * 2, height + blur * 2);

      final int adjX = (int) (x + blur + offsetX + (insets.left * distance));
      final int adjY = (int) (y + blur + offsetY + (insets.top * distance));
      final int adjW = (int) (width - (insets.left + insets.right) * distance);
      final int adjH = (int) (height - (insets.top + insets.bottom) * distance);

      // let the delegate paint whatever they want to be blurred
      imgG.setComposite(AlphaComposite.DstAtop);
      if (prePainter != null) prePainter.paint(imgG, adjX, adjY, adjW, adjH);
      imgG.dispose();

      // blur the prior image back into the same pixels
      imgG = (Graphics2D) img.getGraphics();
      imgG.setComposite(AlphaComposite.DstAtop);
      imgG.setRenderingHint(
          RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
      imgG.setRenderingHint(
          RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
      imgG.drawImage(img, blurOp, 0, 0);

      if (postPainter != null) postPainter.paint(imgG, adjX, adjY, adjW, adjH);
      imgG.dispose();
    }
示例#2
0
  /**
   * Creates an BufferedImage of the passed slide.
   *
   * @param tmpslide slide to copied to a BufferedImage.
   * @param dimension Dimension, the dimension of the slide
   * @param tmpimgWidth int, width which the slide will be scaled to.
   * @param tmpImgHeight int, height which the slide will be scaled to.
   * @return BufferedImage, the image scaled image copy of the slide.
   */
  private BufferedImage slideToImage(Slide tmpslide, Dimension dimension) {

    BufferedImage img =
        new BufferedImage(dimension.width, dimension.height, BufferedImage.TYPE_INT_RGB);

    // create the graphic "painter"
    Graphics2D graphics = img.createGraphics();

    graphics.setRenderingHint(
        RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
    graphics.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics.setRenderingHint(
        RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    graphics.setPaint(Color.white);

    // creates a square
    graphics.fill(new Rectangle2D.Float(0, 0, dimension.width, dimension.height));

    // render image in the square
    tmpslide.draw(graphics);

    return img;
  }
示例#3
0
  @Override
  public void paint(Graphics g) {
    super.paint(g);

    Graphics2D g2 = (Graphics2D) g;

    g2.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    int v = value;
    boolean is_ng = false;
    if (v > 999) v = 999;
    if (v < 0) {
      v *= -1;
      is_ng = true;
      if (v > 99) v = 99;
    }
    for (int i = 2, p = 1; i >= 0; i--, v /= 10) {
      BufferedImage r = GameResource.sevenSegmentDigits[v % 10];
      g2.drawImage(r, i * 15 + 5, 5, 15, 30, this);
    }
    if (is_ng) {
      BufferedImage r = GameResource.sevenSegmentDigits[10];
      g2.drawImage(r, 0 * 15 + 5, 5, 15, 30, this);
    }
  }
示例#4
0
  public void paint(Graphics g) {
    Graphics2D gc = (Graphics2D) g;
    // for antialiasing text
    gc.setRenderingHint(
        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    gc.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    gc.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

    Dimension d = getSize();
    // System.out.println(d.width + "x" + d.height);
    // System.out.println(d.width + "," + d.height);
    int w = d.width - 1;
    int h = d.height - 1;
    float brightness = (float) Settings.brightness.getDouble();
    gc.setColor(Color.black);
    gc.fillRect(0, 0, getWidth(), getHeight());

    gc.setColor(new Color(brightness, brightness, brightness));

    if (mouseInside) gc.drawRoundRect(0, 0, w, h, 8, 8);
    else gc.drawRect(0, 0, w, h);
    FontMetrics fm = gc.getFontMetrics();
    Rectangle2D sb = fm.getStringBounds(text, gc);
    double x = (d.width - sb.getWidth()) / 2;
    double y = (d.height + sb.getHeight()) / 2 - fm.getDescent();
    gc.drawString(text, (int) Math.round(x), (int) Math.round(y));
  }
示例#5
0
 BufferedImage drawText(boolean doGV) {
   int w = 400;
   int h = 50;
   BufferedImage bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
   Graphics2D g = bi.createGraphics();
   g.setColor(Color.white);
   g.fillRect(0, 0, w, h);
   g.setColor(Color.black);
   Font f = helvFont.deriveFont(Font.PLAIN, 40);
   g.setFont(f);
   int x = 5;
   int y = h - 10;
   if (doGV) {
     FontRenderContext frc = new FontRenderContext(null, true, true);
     GlyphVector gv = f.createGlyphVector(frc, codes);
     g.drawGlyphVector(gv, 5, y);
   } else {
     g.setRenderingHint(
         RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
     g.setRenderingHint(
         RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
     g.drawString(str, x, y);
   }
   return bi;
 }
  @Override
  public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
    final Graphics2D g2d = (Graphics2D) g;
    final Insets ins = getBorderInsets(c);
    final int yOff = (ins.top + ins.bottom) / 4;
    final boolean square = DarculaButtonUI.isSquare(c);
    int offset = JBUI.scale(square ? 1 : getOffset());
    if (c.hasFocus()) {
      DarculaUIUtil.paintFocusRing(g2d, offset, yOff, width - 2 * offset, height - 2 * yOff);
    } else {
      final GraphicsConfig config = new GraphicsConfig(g);
      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_DEFAULT);
      g2d.setPaint(
          UIUtil.getGradientPaint(
              width / 2,
              y + yOff + 1,
              Gray._80.withAlpha(90),
              width / 2,
              height - 2 * yOff,
              Gray._90.withAlpha(90)));
      // g.drawRoundRect(x + offset + 1, y + yOff + 1, width - 2 * offset, height - 2*yOff, 5, 5);

      ((Graphics2D) g).setPaint(Gray._100.withAlpha(180));
      g.drawRoundRect(
          x + offset,
          y + yOff,
          width - 2 * offset,
          height - 2 * yOff,
          JBUI.scale(square ? 3 : 5),
          JBUI.scale(square ? 3 : 5));

      config.restore();
    }
  }
  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2 = (Graphics2D) g.create();

    int width = getWidth();
    int height = getHeight();

    // rendering hints
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setRenderingHint(
        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

    // formatter
    DecimalFormat format = new DecimalFormat("##.#%");
    // text to display
    String percentage =
        (value == null || Double.parseDouble(value.toString()) == -1)
            ? ""
            : format.format(Double.parseDouble(value.toString()));

    // paint text
    g2.setColor(Color.black);
    g2.setFont(g2.getFont().deriveFont(Font.BOLD));
    FontMetrics fontMetrics = g2.getFontMetrics();
    int textWidth = fontMetrics.stringWidth(percentage);
    int xPos = (width - textWidth) / 2;
    int yPos = height / 2 + fontMetrics.getDescent() + 2;
    g2.drawString(percentage, xPos, yPos);

    g2.dispose();
  }
示例#8
0
  /** Creates and initializes a splash screen based on image shown by vm while starting. */
  private void createSplashscreen() {

    // Create splash screen only when not yet happened.
    if (splash != null) {

      splashGraphics = splash.createGraphics();

      if (splashGraphics != null) {

        final Color splashscreenColor = new Color(85, 85, 85);
        final int versionX = 38;
        final int versionY = 126;
        final float versionFontSize = 18;
        final String versionString = RunUI.class.getPackage().getSpecificationVersion();

        splashGraphics.setRenderingHint(
            RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        splashGraphics.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        splashGraphics.setRenderingHint(
            RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        splashGraphics.setRenderingHint(
            RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

        splashGraphics.setColor(splashscreenColor);
        splashGraphics.setFont(FontFactory.createSplashscreenFont().deriveFont(versionFontSize));

        splashGraphics.setPaintMode();
        splashGraphics.drawString("Version " + versionString, versionX, versionY);
        splash.update();

        splashGraphics.setFont(FontFactory.createSplashscreenFont());
      }
    }
  }
示例#9
0
 /**
  * Updates a Graphics according to this context
  *
  * @param g Graphics to be updated
  */
 public void updateGraphics(Graphics2D g) {
   g.setFont(font);
   g.setColor(color);
   g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
   g.setRenderingHint(
       RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 }
示例#10
0
    public @Override void paint(Graphics g) {
      if (!indicatorLabel.getFont().equals(chartFrame.getChartProperties().getFont()))
        indicatorLabel.setFont(chartFrame.getChartProperties().getFont());
      if (!indicatorLabel.getForeground().equals(chartFrame.getChartProperties().getFontColor()))
        indicatorLabel.setForeground(chartFrame.getChartProperties().getFontColor());
      if (!indicatorLabel.getText().equals(indicator.getLabel()))
        indicatorLabel.setText(indicator.getLabel());

      Rectangle oldClip = g.getClipBounds();
      Rectangle newClip = getBounds();
      g.setClip(newClip);

      Graphics2D g2 = (Graphics2D) g.create();

      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2.setRenderingHint(
          RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
      g2.setRenderingHint(
          RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);

      g2.setPaintMode();

      if (mouseOver) {
        g2.setColor(backColor);
        RoundRectangle2D roundRectangle =
            new RoundRectangle2D.Double(getX(), getY(), getWidth(), getHeight(), 10, 10);
        g2.fill(roundRectangle);
      }

      super.paint(g);

      g2.dispose();
      g.setClip(oldClip);
    }
示例#11
0
  public static void setupAntialiasing(final Graphics g) {
    if (DEFAULT_ALIASING) return;

    Graphics2D g2d = (Graphics2D) g;
    UISettings uiSettings = getInstance();

    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    if (uiSettings == null || uiSettings.ANTIALIASING_IN_EDITOR) {
      Toolkit tk = Toolkit.getDefaultToolkit();
      //noinspection HardCodedStringLiteral
      Map map = (Map) tk.getDesktopProperty("awt.font.desktophints");
      if (map != null) {
        if (isRemoteDesktopConnected()) {
          g2d.setRenderingHint(
              RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);
        } else {
          g2d.addRenderingHints(map);
        }
      } else {
        g2d.setRenderingHint(
            RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
      }
    } else {
      g2d.setRenderingHint(
          RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
    }
  }
示例#12
0
  public void paintComponent(Graphics g) {
    Color controle = UIManager.getColor("control");
    int width = getWidth() - 6;
    int height = getHeight() - 6;

    Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setRenderingHint(
        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    g2.setRenderingHint(
        RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);

    RoundRectangle2D rect = new RoundRectangle2D.Double(0, 0, width, height, 12, 12);
    drawShadow(g2, rect);

    Paint pinceau = g2.getPaint();
    if (!mouseOver) {
      g2.setPaint(new GradientPaint(this.icon.getIconWidth(), 0, Color.white, width, 0, controle));
    } else {
      g2.setColor(Color.white);
    }

    g2.translate(2, 2);
    if (mousePressed) {
      g2.translate(1, 1);
    }

    g2.fill(rect);
    g2.setPaint(pinceau);
    g2.translate(-2, -2);
  }
示例#13
0
  // <editor-fold defaultstate="collapsed" desc="Visualization">
  @Override
  protected void paintComponent(Graphics g) {
    final Graphics2D G2 = (Graphics2D) g.create();

    G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    G2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    G2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
    G2.setRenderingHint(
        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

    // Translate the coordinate system related to insets
    G2.translate(getFramelessOffset().getX(), getFramelessOffset().getY());

    // Draw combined background image
    G2.drawImage(bImage, 0, 0, null);

    // Draw the symbol image
    if (on) {
      G2.drawImage(symbolOnImage, 0, 0, null);
    } else {
      G2.drawImage(symbolOffImage, 0, 0, null);
    }

    // Draw combined foreground image
    G2.drawImage(fImage, 0, 0, null);

    if (!isEnabled()) {
      G2.drawImage(disabledImage, 0, 0, null);
    }

    // Translate the coordinate system back to original
    G2.translate(-getInnerBounds().x, -getInnerBounds().y);

    G2.dispose();
  }
示例#14
0
 public static void antialias(Graphics g) {
   Graphics2D g2d = (Graphics2D) g;
   g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
   g2d.setRenderingHint(
       RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 }
  /**
   * Creates buffered image from path of width.
   *
   * @param path
   * @param width
   * @return
   * @throws IOException
   */
  private BufferedImage getScaledBufferedImage(String path, int width) {
    BufferedImage bi;

    Image tmp = null;

    try {
      // loads image from path and scales it to desired size
      tmp = getScaledImage(path, width);
    } catch (IOException ex) {
      // should never happen, all hwComponentType default icons are in .jar as a resource
    }

    // create new buffered image to paint on
    bi = new BufferedImage(tmp.getWidth(null), tmp.getHeight(null), BufferedImage.TYPE_INT_ARGB);

    // create graphics and set hints
    Graphics2D graphics2D = bi.createGraphics();
    graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics2D.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

    // draw image
    graphics2D.drawImage(tmp, 0, 0, null);

    graphics2D.dispose();

    return bi;
  }
示例#16
0
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(
        RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON); // Add antialiasing to smooth the lines of the cube
    g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

    g2.translate(getWidth() / 2, getHeight() / 2); // Center the frame

    // g2.fillOval(-2, -2, 4, 4); //Draw the (0, 0) for reference

    for (int i = 0; i < adjacency.getNbRows(); i++) {
      for (int j = 0; j < adjacency.getNbColumns(); j++) {
        if (adjacency.getEntry(i, j) == 1) {

          /*if(calcPoints[i].getEntry(3, 1) > 0.05 || calcPoints[j].getEntry(3, 1) > 0.05)
          	g2.setColor(Color.RED);
          else*/
          g2.setColor(Color.BLACK);

          g2.drawLine(
              (int) (calcPoints[i].getEntry(0, 0) * FACTOR),
              (int) (calcPoints[i].getEntry(1, 0) * FACTOR),
              (int) (calcPoints[j].getEntry(0, 0) * FACTOR),
              (int) (calcPoints[j].getEntry(1, 0) * FACTOR));
        }
      }
    }
  }
示例#17
0
  @Override
  public BufferedImage makeIcon(
      final int width, final int height, final Path2D iconShape, final boolean allowAlpha) {
    final BufferedImage result = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    final Graphics2D g = result.createGraphics();

    g.setStroke(new BasicStroke(0.05f));

    final Color c;
    if (allowAlpha) {
      c =
          new Color(
              this.color.getRed(),
              this.color.getGreen(),
              this.color.getBlue(),
              this.color.getAlpha());
    } else {
      c = new Color(this.color.getRGB());
    }

    if (iconShape != null) {
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g.setRenderingHint(
          RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
      g.setColor(c);
      final Shape path = makeTransformedPathForSize(width, height, iconShape);
      g.fill(path);
    } else {
      g.setColor(c);
      g.fillRect(0, 0, width, height);
    }
    g.dispose();
    return result;
  }
  @Override
  public void paint(Graphics2D graphics, Dimension dimensions) {

    final Color SHADOW_COLOR = new Color(0.0f, 0.0f, 0.0f, 0.65f);

    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    graphics.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
    // graphics.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
    // RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
    // graphics.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
    // RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    graphics.setRenderingHint(
        RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
    // graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
    // RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    final int imageWidth = (int) dimensions.getWidth();
    final int imageHeight = (int) dimensions.getHeight();

    final GeneralPath pointerShape;

    pointerShape = new GeneralPath();
    pointerShape.setWindingRule(Path2D.WIND_EVEN_ODD);
    pointerShape.moveTo(0.5 * imageWidth, 0.16822429906542055 * imageHeight);
    pointerShape.lineTo(0.48598130841121495 * imageWidth, 0.5 * imageHeight);
    pointerShape.lineTo(0.5 * imageWidth, 0.5046728971962616 * imageHeight);
    pointerShape.lineTo(0.5093457943925234 * imageWidth, 0.5 * imageHeight);
    pointerShape.lineTo(0.5 * imageWidth, 0.16822429906542055 * imageHeight);
    pointerShape.closePath();
    graphics.setColor(SHADOW_COLOR);
    graphics.fill(pointerShape);

    graphics.dispose();
  }
  public BufferedImage generateImageFromDna(
      List<Gene> dna, GAParameters parameters, double multiplier) {
    //        long timestamp = System.currentTimeMillis();
    BufferedImage image =
        new BufferedImage(
            (int) (parameters.getTargetImage().getWidth() * multiplier),
            (int) (parameters.getTargetImage().getHeight() * multiplier),
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D graphics = image.createGraphics();
    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics.setRenderingHint(
        RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);

    drawBlackBackground(graphics, parameters, multiplier);

    for (Gene gene : dna) {
      int[] x = new int[gene.getPoints().size()];
      int[] y = new int[gene.getPoints().size()];

      for (int i = 0; i < gene.getPoints().size(); i++) {
        x[i] = (int) (gene.getPoints().get(i).getX() * multiplier);
        y[i] = (int) (gene.getPoints().get(i).getY() * multiplier);
      }

      Polygon p = new Polygon(x, y, gene.getPoints().size());
      graphics.setColor(gene.getColor());
      graphics.fillPolygon(p);
    }
    //        System.out.println("rendering took : " + (System.currentTimeMillis() - timestamp));
    return image;
  }
  public int getBitmapFontRAMUsage() {
    BufferedImage image = new BufferedImage(50, 50, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2d = (Graphics2D) image.getGraphics();
    g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2d.setRenderingHint(
        RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
    g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, bitmapAntialiasing);
    g2d.setFont(java.awt.Font.decode(lookupFont));
    FontMetrics metrics = g2d.getFontMetrics();
    FontRenderContext context = g2d.getFontRenderContext();
    int baseline = (int) Math.ceil(metrics.getMaxAscent());
    int[] offsets = new int[bitmapCharset.length()];
    int[] widths = new int[offsets.length];
    int currentOffset = 0;
    for (int iter = 0; iter < bitmapCharset.length(); iter++) {
      offsets[iter] = currentOffset;
      String currentChar = bitmapCharset.substring(iter, iter + 1);
      g2d.drawString(currentChar, currentOffset, baseline);
      Rectangle2D rect = g2d.getFont().getStringBounds(currentChar, context);
      widths[iter] = (int) Math.ceil(rect.getWidth());

      // max advance works but it makes a HUGE image in terms of width which
      // occupies more ram
      if (g2d.getFont().isItalic()) {
        currentOffset += metrics.getMaxAdvance();
      } else {
        currentOffset += widths[iter] + 1;
      }
    }
    g2d.dispose();
    return currentOffset * getHeight() * 4;
  }
 public static void drawStringUnderlineCharAt(
     JComponent c, Graphics g, String text, int underlinedIndex, int x, int y) {
   Graphics2D g2D = (Graphics2D) g;
   Object savedRenderingHint = null;
   if (AbstractLookAndFeel.getTheme().isTextAntiAliasingOn()) {
     savedRenderingHint = g2D.getRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING);
     g2D.setRenderingHint(
         RenderingHints.KEY_TEXT_ANTIALIASING,
         AbstractLookAndFeel.getTheme().getTextAntiAliasingHint());
   }
   if (getJavaVersion() >= 1.6) {
     try {
       Class swingUtilities2Class = Class.forName("sun.swing.SwingUtilities2");
       Class classParams[] = {
         JComponent.class, Graphics.class, String.class, Integer.TYPE, Integer.TYPE, Integer.TYPE
       };
       Method m = swingUtilities2Class.getMethod("drawStringUnderlineCharAt", classParams);
       Object methodParams[] = {
         c, g, text, new Integer(underlinedIndex), new Integer(x), new Integer(y)
       };
       m.invoke(null, methodParams);
     } catch (Exception ex) {
       BasicGraphicsUtils.drawString(g, text, underlinedIndex, x, y);
     }
   } else if (getJavaVersion() >= 1.4) {
     BasicGraphicsUtils.drawStringUnderlineCharAt(g, text, underlinedIndex, x, y);
   } else {
     BasicGraphicsUtils.drawString(g, text, underlinedIndex, x, y);
   }
   if (AbstractLookAndFeel.getTheme().isTextAntiAliasingOn()) {
     g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, savedRenderingHint);
   }
 }
示例#22
0
 @Override
 public void paintComponent(Graphics g) {
   Graphics2D g2 = (Graphics2D) g;
   g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
   super.paintComponent(g2);
 }
  @Override
  public void paint(Graphics g, JComponent c) {
    Graphics2D g2 = (Graphics2D) g;
    AbstractButton b = (AbstractButton) c;
    ButtonModel model = b.getModel();
    initShape(b);
    // ContentArea
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    if (model.isArmed()) {
      g2.setColor(ac);
      g2.fill(shape);
    } else if (b.isRolloverEnabled() && model.isRollover()) {
      paintFocusAndRollover(g2, c, rc);
    } else if (b.hasFocus()) {
      paintFocusAndRollover(g2, c, fc);
    } else {
      g2.setColor(c.getBackground());
      g2.fill(shape);
    }
    // Border
    g2.setPaint(c.getForeground());
    g2.draw(shape);

    g2.setColor(c.getBackground());
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    super.paint(g2, c);
  }
  public static void drawLabel(
      Graphics2D g2,
      FontMetrics f,
      Pixel highest,
      String label,
      Color edgeColor,
      Color bgColor,
      Color textColor) {

    int lineHeight = 20;
    int padding = 3;
    Rectangle2D r = f.getStringBounds(label, g2);
    int halfStringWidth = (int) (r.getWidth() / 2);
    int halfStringHeight = (int) (r.getHeight() / 2);
    int stringWidth = halfStringWidth * 2;
    int stringHeight = halfStringHeight * 2;

    g2.setColor(bgColor);
    g2.fillRect(
        highest.x - halfStringWidth - padding,
        highest.y - lineHeight - stringHeight - padding - padding,
        stringWidth + padding + padding,
        stringHeight + padding + padding);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setColor(textColor);
    g2.drawString(label, highest.x - halfStringWidth, highest.y - lineHeight - halfStringHeight);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    g2.setColor(edgeColor);
    g2.drawRect(
        highest.x - halfStringWidth - padding,
        highest.y - lineHeight - stringHeight - padding - padding,
        stringWidth + padding + padding,
        stringHeight + padding + padding);
    g2.drawLine(highest.x, highest.y, highest.x, highest.y - lineHeight);
  }
示例#25
0
 /**
  * Renders the given range in the model as normal unselected text. This is implemented to paint
  * colors based upon the token-to-color translations.
  *
  * @param g the graphics context
  * @param x the starting X coordinate
  * @param y the starting Y coordinate
  * @param start the beginning position in the model
  * @param end the ending position in the model
  * @returns the location of the end of the range
  * @exception BadLocationException if the range is invalid
  */
 @Override
 protected int drawUnselectedText(Graphics g, int x, int y, int start, int end)
     throws BadLocationException {
   DocumentImpl doc = (DocumentImpl) getDocument();
   Graphics2D g2 = (Graphics2D) g;
   g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
   g2.setRenderingHint(
       RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
   int mark = start;
   Segment text = new Segment();
   for (Token token : doc.getTokensInRange(start, end)) {
     int endPosition = Math.min(token.getEndOffset(), end);
     token.accept(gd.setGraphics(g2));
     doc.getText(mark, endPosition - mark, text);
     x = Utilities.drawTabbedText(text, x, y, g, this, mark);
     mark = endPosition;
   }
   // tokens may not reach to the end of the area we want rendered
   // so this will make up the remaining space
   if (end != mark) {
     doc.getText(mark, end - mark, text);
     x = Utilities.drawTabbedText(text, x, y, g, this, mark);
   }
   g2.setFont(g2.getFont().deriveFont(Font.PLAIN));
   return x;
 }
  public void exportReportToGraphics2D() throws JRException {
    grx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    // grx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    grx.setRenderingHint(
        RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
    grx.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);

    AffineTransform atrans = new AffineTransform();
    atrans.translate(globalOffsetX, globalOffsetY);
    atrans.scale(zoom, zoom);
    grx.transform(atrans);

    java.util.List pages = jasperPrint.getPages();
    if (pages != null) {
      Shape oldClipShape = grx.getClip();

      grx.clip(new Rectangle(0, 0, jasperPrint.getPageWidth(), jasperPrint.getPageHeight()));

      try {
        JRPrintPage page = (JRPrintPage) pages.get(startPageIndex);
        exportPage(page);
      } finally {
        grx.setClip(oldClipShape);
      }
    }
  }
示例#27
0
  public void paintComponent(Graphics g) {
    super.paintComponent(g);

    int centerX = getWidth() / 2;
    int centerY = getHeight() / 2;

    Graphics2D g2d = (Graphics2D) g.create();

    g2d.translate(centerX, centerY); // Set Graphics2D transform origin to center of panel

    g2d.setColor(fgColor);
    bar.setFrame(-barWidth / 2, -barHeight / 2 + barHeight * barPosition, barWidth, barHeight);
    g2d.fill(bar);
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    for (Spike spike : spikes) {
      if (spike != null) {
        double opacity = 255;
        if (spike.getDirection() == 0) {
          opacity = getWidth() * 0.5 - 70 - spike.getPosition().getX();
        } else {
          opacity = spike.getPosition().getX() + getWidth() * 0.5 - 70;
        }
        g2d.setColor(new Color(0, 0, 0, (int) clamp(opacity * 10, 0, 255)));
        g2d.fill(spike);
      }
    }
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    g2d.setColor(Color.BLACK);
    g2d.draw(barCross);
    g2d.setStroke(new BasicStroke(2));
    g2d.draw(barFrame);
    g2d.dispose();
  }
  private void createImages() {
    int w = 16;
    int h = getPreferredSize().height;
    setTarget(new Rectangle(2, 0, 20, 18));
    Graphics2D g2;

    open = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    g2 = open.createGraphics();
    g2.setPaint(getBackground());
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.fillRect(0, 0, w, h);
    int[] x = {2, w / 2, 14};
    int[] y = {4, 13, 4};
    Polygon p = new Polygon(x, y, 3);
    g2.setPaint(new Color(204, 204, 204));
    g2.fill(p);
    g2.draw(p);
    g2.dispose();

    closed = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    g2 = closed.createGraphics();
    g2.setPaint(getBackground());
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.fillRect(0, 0, w, h);
    x = new int[] {3, 13, 3};
    y = new int[] {4, h / 2, 16};
    p = new Polygon(x, y, 3);
    g2.setPaint(new Color(102, 102, 102));
    g2.fill(p);
    g2.draw(p);
    g2.dispose();
  }
示例#29
0
  private BufferedImage getFontImage(char ch) {
    // Create a temporary image to extract the character's size
    BufferedImage tempfontImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = (Graphics2D) tempfontImage.getGraphics();
    if (antiAlias == true) {
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    }
    g.setFont(font);
    fontMetrics = g.getFontMetrics();
    int charwidth = fontMetrics.charWidth(ch) + 8;

    if (charwidth <= 0) {
      charwidth = 7;
    }
    int charheight = fontMetrics.getHeight() + 3;
    if (charheight <= 0) {
      charheight = fontSize;
    }

    // Create another image holding the character we are creating
    BufferedImage fontImage;
    fontImage = new BufferedImage(charwidth, charheight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D gt = (Graphics2D) fontImage.getGraphics();
    if (antiAlias == true) {
      gt.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    }
    gt.setFont(font);

    gt.setColor(Color.WHITE);
    int charx = 3;
    int chary = 1;
    gt.drawString(String.valueOf(ch), (charx), (chary) + fontMetrics.getAscent());

    return fontImage;
  }
  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    if (!loadingDone && faderTimer == null) {
      return;
    }

    Insets insets = getInsets();

    int x = insets.left;
    int y = insets.top;

    int width = getWidth() - insets.left - insets.right;
    int height = getHeight() - insets.top - insets.bottom;

    Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    Composite oldComposite = g2.getComposite();

    if (damaged) {
      drawableAvatars = sortAvatarsByDepth(x, y, width, height);
      damaged = false;
    }

    drawAvatars(g2, drawableAvatars);

    if (drawableAvatars.length > 0) {
      drawAvatarName(g2);
    }

    g2.setComposite(oldComposite);
  }