コード例 #1
0
  public void paintComponent(Graphics A00) {

    super.paintComponent(A00);

    Graphics2D L00 = (Graphics2D) A00;
    L00.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);

    L00.setColor(I00);
    L00.fillOval(C02 + C03, C02 + C03, C04, C04);

    int L01 = 90; // 円グラフの描画開始角度
    int L02 = 0; // 扇形の中心角

    setRates();

    for (Color L03 : I01.keySet()) {
      L02 = Math.round(360f * I01.get(L03) / I02);
      L01 -= L02;
      L00.setColor(L03);
      L00.fillArc(C02, C02, C04, C04, L01, L02);
    }
    // 四捨五入の都合で塗り残しが出た場合の対処
    L00.fillArc(C02, C02, C04, C04, -270, L02);

    L00.setColor(I00);
    L00.drawOval(C02, C02, C04, C04);
  }
コード例 #2
0
  @Override
  public void paintComponent(Graphics g) {
    super.paintComponent(g);

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

    // Draw each space
    for (int i = 0, degrees = 0; i < imageNames.size() / 2; ++i) {
      g2D.setColor(
          WHEEL_COLORS.get(imageNames.get(i).substring(0, imageNames.get(i).indexOf('.'))));
      g2D.fillArc(150, 45, 480, 480, degrees, DEGREES_EACH);
      degrees += DEGREES_EACH;
    }

    // Set the origin and rotate before drawing the images
    g2D.translate(390, 285);
    g2D.rotate(Math.toRadians(-100));

    // Draw wheel spaces
    for (int i = 0; i < imageNames.size() / 2; ++i) {
      g2D.drawImage(IMAGES.get(imageNames.get(i)), -42, 0, this);
      g2D.rotate(Math.toRadians(-DEGREES_EACH));
    }

    // Reset origin
    g2D.translate(-390, -285);

    // Draw the arrow to indicate where the wheel stopped
    g.drawImage(IMAGES.get("arrow.png"), 370, 10, this);
  }
コード例 #3
0
  private void renderInner(Graphics2D g, int width2, int height2, double[] spaces) {
    double startAngle = 0D;
    DataModel1D model1 = (DataModel1D) this.getDataModel();
    int stop = model1.getSize();
    g.setColor(this.innerColor);
    // g.setColor(Color.BLACK);
    double ratio = 360 / this.getTotalValue().doubleValue();
    int posX = (getCenterX() - this.innerWidth / 2);
    int posY = (getCenterY() - this.innerHeight / 2); //
    // g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
    // RenderingHints.VALUE_ANTIALIAS_OFF);
    for (int i = 0; i < stop; i++) {
      Number n = model1.getValueAt(i);
      if (n == null) {
        continue;
      }
      int angle = (int) Math.round(n.doubleValue() * ratio);
      double moveAngle = startAngle - angle / 2D;
      double angleRadian = ((moveAngle) * Math.PI * 2) / 360;

      double current_space = spaces[i];
      int x = posX + (int) ((Math.cos(angleRadian)) * current_space);
      int y = posY + (int) ((-Math.sin(angleRadian)) * current_space);

      // g.fillArc(x, y, width2 * 2, height2 * 2, (int)
      // Math.round(startAngle), -angle);
      g.fillArc(
          x, y, this.innerWidth, this.innerHeight, (int) Math.round(startAngle) + 50, -angle - 100);

      startAngle -= angle;
    }
  }
コード例 #4
0
ファイル: PieChart.java プロジェクト: redpois0n/graphslib
  @Override
  public void paintComponent(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    int p = startAngle;

    int total = -1;

    for (PieSlice entry : entries) {
      total += entry.getValue();
    }

    for (int i = 0; i < entries.size(); i++) {
      PieSlice entry = entries.get(i);

      g2d.setColor(entry.getColor());

      double val = entry.getValue();
      double angle = (val / total) * 360;

      g2d.fillArc(0, 0, super.getWidth(), super.getWidth(), p, (int) angle);

      p = (int) (p + angle);
    }
  }
コード例 #5
0
      /**
       * A paint class that will draw the needle, dots, and TO/FROM RenderingHints is IMPORTANT. It
       * will make sure that everything stays focused and not blurry whenever the image rotates. I
       * added an empty line between the 8 fillArcs, just so its easier to see that four of them
       * draw on the left side and four draw on the right side.
       */
      public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        RenderingHints hints = new RenderingHints(null);
        hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g2.setRenderingHints(hints);
        g2.setStroke(new BasicStroke(3));
        // g2.drawString("TO", 190, 200);
        if (vor.isTo() == true) {
          if (vor.isAbeamed() == true) {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            // g2.setColor(Color.red);
            // g2.drawString("BAD", 190, 200);
          } else {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            g2.drawString("TO", 190, 200);
          }
        } else if (vor.isFrom() == true) {
          if (vor.isAbeamed() == true) {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            // g2.setColor(Color.red);
            // g2.drawString("BAD", 190, 300);
          } else {
            // g2.setFont(new Font("default", Font.BOLD, 13));
            g2.drawString("FROM", 190, 300);
          }
        } else if (vor.isFrom() == false || vor.isTo() == false) {
          // is above the vor station no to or from
        }

        g2.fillArc(140, 240, 7, 7, 0, 360);
        g2.fillArc(125, 240, 7, 7, 0, 360);
        g2.fillArc(110, 240, 7, 7, 0, 360);
        g2.fillArc(95, 240, 7, 7, 0, 360);

        g2.fillArc(195, 240, 7, 7, 0, 360);
        g2.fillArc(210, 240, 7, 7, 0, 360);
        g2.fillArc(225, 240, 7, 7, 0, 360);
        g2.fillArc(240, 240, 7, 7, 0, 360);

        // g2.drawString("FROM",190, 300);
        g2.drawLine(x, y1, x, y2);
        super.paintComponent(g);
        g2.dispose();
      }
コード例 #6
0
ファイル: FTACanvas.java プロジェクト: jandcmoore/OpenFTA
 private void fillArc(
     int x, int y, int width, int height, int startAngle, int arcAngle, int symbolType) {
   if (!Preferences.monochrome) {
     setFillColor(symbolType);
     gRef.fillArc(x, y, width, height, startAngle, arcAngle);
     restoreColor();
   }
 }
コード例 #7
0
 private static void drawCircle(Graphics2D g2, float x, float y) {
   g2.setColor(blue);
   g2.translate(x, y);
   g2.fillArc(0, 0, 8, 8, 0, 360);
   g2.setColor(Color.BLACK);
   g2.drawArc(0, 0, 8, 8, 0, 360);
   g2.translate(-x, -y);
 }
コード例 #8
0
 @Override
 public void onDraw(Graphics G, int viewX, int viewY) {
   if (X > viewX && X < viewX + 300 && Y > viewY && Y < viewY + 300) {
     Graphics2D g = (Graphics2D) G;
     Composite c = g.getComposite();
     // g.setComposite(new Additive());
     g.setColor(new Color(255, r.nextInt(255), 0, r.nextInt(255)));
     g.fillArc(((int) X - 6) - viewX, (int) (Y - 6) - viewY, 12, 12, 0, 360);
     for (int y = 0; y < 30; y += 3) {
       for (int i = 0; i < 4; i++) {
         int e1 = 6 - r.nextInt(12), e2 = 6 - r.nextInt(12);
         g.setColor(new Color(255, r.nextInt(255), 0, r.nextInt(255)));
         g.fillArc((int) (X + e1) - viewX, (int) (Y + e2 + y) - viewY, e1, e2, 0, 360);
       }
     }
     g.setComposite(c);
   }
 }
コード例 #9
0
  public void paintComponent(Graphics g) {
    setSize(xSize, ySize);
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;

    if (PedigreeExplorer.thickLines) {
      // turn this off so they don't look blurry when exported
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    } else {
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    }
    g2.setColor(Color.black);

    if (PedigreeExplorer.thickLines) {
      g2.setStroke(new BasicStroke(2));
    } else {
      g2.setStroke(new BasicStroke(1));
    }

    if (sex == male) {
      if (PedigreeExplorer.thickLines) {
        g2.drawRect(1, 1, symbolSize - 2, symbolSize - 2);
      } else {
        g2.drawRect(0, 0, symbolSize, symbolSize);
      }

      if (affection == affected) {
        g2.fillRect(0, 0, symbolSize, symbolSize);
      }
    }

    if (sex == female) {
      if (PedigreeExplorer.thickLines) {
        g2.drawArc(1, 1, symbolSize - 2, symbolSize - 2, 0, 360);
      } else {
        g2.drawArc(0, 0, symbolSize, symbolSize, 0, 360);
      }

      if (affection == affected) {
        g2.fillArc(0, 0, symbolSize, symbolSize, 0, 360);
      }
    }
  }
コード例 #10
0
ファイル: OrbitGraph.java プロジェクト: AwesomeAs/Orbit
  @Override
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2d = (Graphics2D) g;

    Point point = MouseInfo.getPointerInfo().getLocation();
    Point loc = getLocationOnScreen();

    g2d.setColor(new Color(20, 90, 95, 100));
    g2d.fillRect(x, y, w, h);
    g2d.setPaint(
        new GradientPaint(
            x, y + 25, new Color(20, 100, 95, 0), x, y + h - 35, new Color(35, 200, 180, 30)));
    g2d.fillRect(x, y + 25, w, h - 60);
    g2d.setStroke(new BasicStroke(1));
    g2d.setColor(new Color(35, 185, 185, 60));
    g2d.drawLine(x, y + h, x + w, y + h);

    Rectangle tview =
        (view.width != 0 && view.height != 0)
            ? view
            : new Rectangle(
                (int) data[0][0],
                minY() - 5,
                (int) data[data.length - 1][0] - (int) data[0][0],
                maxY() - minY() + 10);
    int steps =
        2 + (int) ((Math.log10(tview.height) - Math.floor(Math.log10(tview.height))) * 8) / 2;

    g2d.setClip(x, y, w, h - 35);
    g2d.setColor(new Color(35, 185, 185, 30));
    g2d.setStroke(
        new BasicStroke(
            1.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 1.0f, new float[] {2.0f}, 1.0f));
    for (int i = 1; i < steps; i++) {
      g2d.drawLine(
          x,
          y + (int) (((float) i / steps) * (h - 35)),
          x + w,
          y + (int) (((float) i / steps) * (h - 35)));
    }
    g2d.setColor(new Color(100, 120, 120, 150));
    int ly = y + h - 38 - (int) ((double) ((line - tview.y) / tview.height) * (h - 35));
    g2d.drawLine(x, ly, x + w - 37, ly);
    g2d.drawLine(x + w - 12, ly, x + w, ly);
    g2d.setFont(font);
    g2d.setColor(new Color(100, 10, 0, 20));
    for (int dx = -1; dx < 2; dx++) {
      for (int dy = -1; dy < 2; dy++) {
        g2d.drawString("AVG", x + w - 35 + dx, ly + 4 + dx);
      }
    }
    g2d.setColor(new Color(200, 20, 0, 240));
    g2d.drawString("AVG", x + w - 35, ly + 4);
    g2d.setColor(new Color(25, 185, 120, 150));
    g2d.setStroke(
        new BasicStroke(
            1.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 1.0f, new float[] {3.0f}, 2.0f));
    for (int i = 1; i < secondData.length; i++) {
      int tx = x + (int) ((double) ((secondData[i][0] - tview.x) / tview.width) * w);
      int ty =
          y + h - 35 - (int) ((double) ((secondData[i][1] - tview.y) / tview.height) * (h - 35));
      int px = x + (int) ((double) ((secondData[i - 1][0] - tview.x) / tview.width) * w);
      int py =
          y
              + h
              - 35
              - (int) ((double) ((secondData[i - 1][1] - tview.y) / tview.height) * (h - 35));
      g2d.drawLine(px, py, tx, ty);
    }
    g2d.setStroke(new BasicStroke(1.5f));
    boolean hasHover = false;
    for (int i = 0; i < data.length; i++) {
      if (data[i][0] >= tview.x && data[i][0] <= tview.getMaxX()) {
        if (data[i][1] >= tview.y && data[i][1] <= (int) tview.getMaxY()) {
          int tx = x - 3 + (int) ((double) ((data[i][0] - tview.x) / tview.width) * w);
          int ty = y + h - 38 - (int) ((double) ((data[i][1] - tview.y) / tview.height) * (h - 35));
          boolean hover =
              Math.sqrt(
                      Math.pow(point.x - loc.x - (tx + 3), 2)
                          + Math.pow(point.y - loc.y - (ty + 3), 2))
                  <= 6;
          if (hover) {
            hasHover = true;
            if (lastHover != i) {
              lastHover = i;
              hoverpoint.fire(i, data[i]);
            }
          }
          if (i > 0) {
            int px = x + (int) ((double) ((data[i - 1][0] - tview.x) / tview.width) * w);
            int py =
                y
                    + h
                    - 35
                    - (int) ((double) ((data[i - 1][1] - tview.y) / tview.height) * (h - 35));
            g2d.drawLine(px, py, tx + 3, ty + 3);
          }
          if (hover) {
            g2d.setColor(new Color(35, 185, 185));
            g2d.fillArc(tx, ty, 6, 6, 0, 360);
            g2d.drawArc(tx - 4, ty - 4, 13, 13, 0, 360);
            int tw = textWidth(Integer.toString((int) data[i][1]), g2d);
            boolean above = ty - y > 30;
            int side = tx - x - tw / 2 - 12 < 0 ? 1 : (tx - x + tw / 2 + 12 > w ? -1 : 0);
            g2d.setColor(new Color(0, 0, 0, 200));
            g2d.fillRoundRect(
                tx - tw / 2 - 8 + (side * (tw + 10)),
                side != 0 ? ty - 8 : (above ? ty - 28 : ty + 13),
                tw + 16,
                19,
                4,
                4);
            g2d.setPaint(
                new GradientPaint(
                    tx,
                    side != 0 ? ty - 6 : (above ? ty - 25 : ty + 16),
                    new Color(25, 90, 95, 140),
                    tx,
                    side != 0 ? ty + 6 : (above ? ty - 12 : ty + 29),
                    new Color(30, 135, 137, 160)));
            g2d.fillRoundRect(
                tx - tw / 2 - 8 + (side * (tw + 10)),
                side != 0 ? ty - 8 : (above ? ty - 28 : ty + 13),
                tw + 16,
                19,
                4,
                4);
            g2d.setColor(new Color(35, 185, 185));
            g2d.drawString(
                Integer.toString((int) data[i][1]),
                tx - tw / 2 + (side * (tw + 10)),
                side != 0 ? ty + 5 : (above ? ty - 15 : ty + 26));
            g2d.setColor(new Color(35, 185, 185, 200));
          } else {
            g2d.setColor(new Color(35, 185, 185, 200));
            g2d.drawArc(tx, ty, 6, 6, 0, 360);
          }
        }
      }
    }
    if (!hasHover) lastHover = -1;
    g2d.setColor(new Color(35, 200, 120, 200));
    g2d.setClip(null);
    g2d.setColor(new Color(0, 0, 0, 200));
    g2d.fillRect(x, y, 30, h - 35);
    g2d.setPaint(
        new GradientPaint(
            x, y, new Color(35, 175, 185, 45), x, y + h - 35, new Color(25, 150, 145, 100)));
    g2d.fillRect(x, y, 30, h - 35);
    g2d.setColor(new Color(35, 185, 185));
    for (int i = 1; i < steps; i++) {
      float perc = ((float) i / steps);
      g2d.drawString(
          format((int) (tview.y + perc * tview.height)),
          x + 9,
          y + h - 31 - (int) (perc * (h - 35)));
    }
    g2d.setClip(x, y + h - 35, w, 35);
    for (int i = 0; i < bottomLabels.length; i++) {
      float perc = (float) (((double) i * labelInterval) + labelStart - tview.x) / (tview.width);
      if (perc > -0.2 && perc < 1.2) {
        if (perc > 0.9) {
          g2d.setColor(new Color(35, 185, 185, 255 - (int) ((perc - 0.9) * 10 * 200)));
        } else if (perc < 0.1) {
          g2d.setColor(new Color(35, 185, 185, 55 + (int) ((perc) * 10 * 200)));
        } else {
          g2d.setColor(new Color(35, 185, 185, 255));
        }
        g2d.drawString(
            bottomLabels[i], x + perc * w - textWidth(bottomLabels[i], g2d) / 2, y + h - 12);
      }
    }
    g2d.setClip(null);
  }
コード例 #11
0
  /**
   * The GraphicDrawer.paint() Function allows the user to draw pre-defined graphics into a given
   * Graphics Object. The user may give the rectangle properties which defines at best the desired
   * area to draw with a Int id which requests the desired graphic, whenever it's vectorial or
   * raster graphics
   *
   * @author LuisArturo
   */
  public void paint(int id, Dimension r, Graphics g) {
    Graphics2D g2;
    switch (id) {
      case FILE:
        {
          g2 = (Graphics2D) g;
          try {
            FileInputStream img = new FileInputStream("archivo.png");
            BufferedImage in = ImageIO.read(img);
            g2.drawImage(
                in, r.width * 2 / 10, r.height * 2 / 10, r.width * 2 / 3, r.height * 2 / 3, null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        break;
      case REDO:
        {
          g2 = (Graphics2D) g;
          g2.setColor(color);
          g2.fillArc(
              r.width * 2 / 10, r.height * 2 / 10, r.width * 6 / 10, r.height * 6 / 10, 270, 225);
          Polygon p = new Polygon();
          p.addPoint(r.width * 2 / 10, r.height * 2 / 10);
          p.addPoint(r.width * 2 / 10, r.height * 5 / 10);
          p.addPoint(r.width * 5 / 10, r.height * 5 / 10);
          g2.fillPolygon(p);
          g2.setColor(g2.getBackground());
          g2.fillArc(
              r.width * 3 / 10, r.height * 3 / 10, r.width * 4 / 10, r.height * 4 / 10, 270, 225);
        }
        break;
      case TEXT:
        {
          g2 = (Graphics2D) g;
          g2.setColor(color);
          g2.setFont(new Font("Serif", Font.ITALIC | Font.BOLD, r.height * 6 / 10));
          g2.drawChars("A".toCharArray(), 0, 1, r.width * 3 / 10, r.height * 7 / 10);
        }
        break;
      case SELECT:
        {
          g2 = (Graphics2D) g;
          try {
            FileInputStream img = new FileInputStream("mano.png");
            BufferedImage in = ImageIO.read(img);
            g2.drawImage(
                in, r.width * 1 / 10, r.height * 1 / 10, r.width * 2 / 3, r.height * 2 / 3, null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        break;
      case PENCIL:
        {
          g2 = (Graphics2D) g;
          try {
            FileInputStream img = new FileInputStream("lapiz.png");
            BufferedImage in = ImageIO.read(img);
            g2.drawImage(
                in, r.width * 2 / 10, r.height * 2 / 10, r.width * 2 / 3, r.height * 2 / 3, null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        break;

      case ARROW:
        {
          g2 = (Graphics2D) g;
          try {
            FileInputStream img = new FileInputStream("arrow.png");
            BufferedImage in = ImageIO.read(img);
            g2.drawImage(
                in, r.width * 2 / 10, r.height * 2 / 10, r.width * 2 / 3, r.height * 2 / 3, null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        break;
      case ZOOM:
        {
          g2 = (Graphics2D) g;
          try {
            FileInputStream img = new FileInputStream("zoom.png");
            BufferedImage in = ImageIO.read(img);
            g2.drawImage(
                in, r.width * 2 / 10, r.height * 2 / 10, r.width * 2 / 3, r.height * 2 / 3, null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        break;
    }
  }
コード例 #12
0
ファイル: JCanvas.java プロジェクト: xaleth09/Connect4-AI
 // 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);
   }
 }
コード例 #13
0
  private void render(Graphics g, int drawingPage, double scale) {
    Graphics2D g2 = (Graphics2D) g;
    g2.scale(scale, scale);
    int pageIndex;
    paperPanel.setPreferredSize(new Dimension(600, numberOfPages * (pageHeight + 25)));

    for (int page = 0; page < numberOfPages; page++) {
      g2.setColor(Color.white);
      g2.fillRect(0, page * (pageHeight + 25), pageWidth, pageHeight);
    }

    g2.setColor(Color.black);

    for (Object[] task : elements) {
      switch ((Integer) task[0]) {
        case DRAW_STRING:
          FontMetrics metrics = getFontMetrics(g2.getFont());
          String string = task[1].toString();
          int x = (Integer) task[2];
          int y = (Integer) task[3];
          pageIndex = (Integer) task[4];
          if (drawingPage == -1) y += (pageIndex * (pageHeight + 25));
          int width = metrics.stringWidth(string);
          if (drawingPage == -1 || drawingPage == pageIndex) {
            if (currentAlignment == LEFT) {
              g2.drawString(string, x, y);
              if (underline) {
                g2.drawLine(x, y + 3, x + width, y + 3);
              }
            } else if (currentAlignment == RIGHT) {
              g2.drawString(string, x - width, y);
              if (underline) {
                g2.drawLine(x, y + 3, x - width, y + 3);
              }
            } else if (currentAlignment == CENTER) {
              g2.drawString(string, x - (width / 2), y);
              if (underline) {
                g2.drawLine(x - (width / 2), y + 3, x + (width / 2), y + 3);
              }
            }
          }
          break;
        case DRAW_LINE:
          int x1 = (Integer) task[1],
              y1 = (Integer) task[2],
              x2 = (Integer) task[3],
              y2 = (Integer) task[4];
          pageIndex = (Integer) task[5];
          if (drawingPage == -1)
            g2.drawLine(
                x1, (pageIndex * (pageHeight + 25)) + y1, x2, (pageIndex * (pageHeight + 25)) + y2);
          else if (drawingPage == pageIndex) g2.drawLine(x1, y1, x2, y2);
          break;
        case DRAW_RECT:
          int rectX = (Integer) task[1],
              rectY = (Integer) task[2],
              rectWidth = (Integer) task[3],
              rectHeight = (Integer) task[4];
          pageIndex = (Integer) task[5];
          if (drawingPage == -1)
            g2.drawRect(rectX, (pageIndex * (pageHeight + 25)) + rectY, rectWidth, rectHeight);
          else if (drawingPage == pageIndex) g2.drawRect(rectX, rectY, rectWidth, rectHeight);
          break;
        case DRAW_OVAL:
          int ovalX = (Integer) task[1],
              ovalY = (Integer) task[3],
              ovalWidth = (Integer) task[3],
              ovalHeight = (Integer) task[4];
          pageIndex = (Integer) task[5];
          if (drawingPage == -1)
            g2.drawOval(ovalX, (pageIndex * (pageHeight + 25)) + ovalY, ovalWidth, ovalHeight);
          else if (drawingPage == pageIndex) g2.drawOval(ovalX, ovalY, ovalWidth, ovalHeight);
          break;
        case DRAW_IMAGE:
          Image image = (Image) task[1];
          int imageX = (Integer) task[2],
              imageY = (Integer) task[3],
              imageWidth = (Integer) task[4],
              imageHeight = (Integer) task[5];
          pageIndex = (Integer) task[6];
          if (drawingPage == -1)
            g2.drawImage(
                image,
                imageX,
                (pageIndex * (pageHeight + 25)) + imageY,
                imageWidth,
                imageHeight,
                this);
          else if (drawingPage == pageIndex)
            g2.drawImage(image, imageX, imageY, imageWidth, imageHeight, this);
          break;
        case DRAW_POLYGON:
          int[] xPoints = (int[]) task[1], yPoints = (int[]) task[2];
          int numberOfPoints = (Integer) task[3];
          pageIndex = (Integer) task[4];
          if (drawingPage == -1) {
            for (int i = 0; i < yPoints.length; i++) {
              yPoints[i] += (pageIndex * (pageHeight + 25));
            }
            g2.drawPolygon(xPoints, yPoints, numberOfPoints);
          } else if (drawingPage == pageIndex) g2.drawPolygon(xPoints, yPoints, numberOfPoints);
          break;
        case DRAW_ARC:
          int arcX = (Integer) task[1],
              arcY = (Integer) task[2],
              arcWidth = (Integer) task[3],
              arcHeight = (Integer) task[4],
              startAngle = (Integer) task[5],
              arcAngle = (Integer) task[6];
          pageIndex = (Integer) task[7];
          if (drawingPage == -1)
            g2.drawArc(
                arcX,
                (pageIndex * (pageHeight + 25)) + arcY,
                arcWidth,
                arcHeight,
                startAngle,
                arcAngle);
          else if (drawingPage == pageIndex)
            g2.drawArc(arcX, arcY, arcWidth, arcHeight, startAngle, arcAngle);
          break;
        case FILL_RECT:
          int fillRectX = (Integer) task[1],
              fillRectY = (Integer) task[2],
              fillRectWidth = (Integer) task[3],
              fillRectHeight = (Integer) task[4];
          pageIndex = (Integer) task[5];
          if (drawingPage == -1)
            g2.fillRect(
                fillRectX,
                (pageIndex * (pageHeight + 25)) + fillRectY,
                fillRectWidth,
                fillRectHeight);
          else if (drawingPage == pageIndex)
            g2.fillRect(fillRectX, fillRectY, fillRectWidth, fillRectHeight);
          break;
        case FILL_OVAL:
          int fillOvalX = (Integer) task[1],
              fillOvalY = (Integer) task[2],
              fillOvalWidth = (Integer) task[3],
              fillOvalHeight = (Integer) task[4];
          pageIndex = (Integer) task[5];
          if (drawingPage == -1)
            g2.fillOval(
                fillOvalX,
                (pageIndex * (pageHeight + 25)) + fillOvalY,
                fillOvalWidth,
                fillOvalHeight);
          else if (drawingPage == pageIndex)
            g2.fillOval(fillOvalX, fillOvalY, fillOvalWidth, fillOvalHeight);
          break;
        case FILL_POLYGON:
          int[] fillXPoints = (int[]) task[1], fillYPoints = (int[]) task[2];
          int fillNumberOfPoints = (Integer) task[3];
          pageIndex = (Integer) task[4];
          if (drawingPage == -1) {
            for (int i = 0; i < fillYPoints.length; i++) {
              fillYPoints[i] += (pageIndex * (pageHeight + 25));
            }
            g2.fillPolygon(fillXPoints, fillYPoints, fillNumberOfPoints);
          } else if (drawingPage == pageIndex)
            g2.fillPolygon(fillXPoints, fillYPoints, fillNumberOfPoints);
          break;
        case FILL_ARC:
          int fillArcX = (Integer) task[1],
              fillArcY = (Integer) task[2],
              fillArcWidth = (Integer) task[3],
              fillArcHeight = (Integer) task[4],
              fillStartAngle = (Integer) task[5],
              fillArcAngle = (Integer) task[6];
          pageIndex = (Integer) task[7];
          if (drawingPage == -1)
            g2.fillArc(
                fillArcX,
                (pageIndex * (pageHeight + 25)) + fillArcY,
                fillArcWidth,
                fillArcHeight,
                fillStartAngle,
                fillArcAngle);
          else if (drawingPage == pageIndex)
            g2.fillArc(
                fillArcX, fillArcY, fillArcWidth, fillArcHeight, fillStartAngle, fillArcAngle);
          break;
        case SET_COLOR:
          g2.setColor((Color) task[1]);
          break;
        case SET_FONT:
          g2.setFont((Font) task[1]);
          break;
        case SET_STROKE:
          g2.setStroke((Stroke) task[1]);
          break;
        case SET_PAINT:
          g2.setPaint((Paint) task[1]);
          break;
        case SET_ALIGNMENT:
          currentAlignment = (Integer) task[1];
          break;
        case SET_STYLE:
          int style = (Integer) task[1];
          //				currentStyle = style;
          styleFont = currentFont.deriveFont(Font.PLAIN);
          if (style == BOLD) styleFont = styleFont.deriveFont(Font.BOLD);
          if (style == ITALIC) styleFont = styleFont.deriveFont(Font.ITALIC);
          underline = (style == UNDERLINE);
          if (style == BOLD_UNDERLINE) {
            styleFont = styleFont.deriveFont(Font.BOLD);
            underline = true;
          }
          g2.setFont(styleFont);
          break;
      }
    }
  }
コード例 #14
0
 public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   g2d.fillArc(x, y, width, height, startAngle, arcAngle);
 }
コード例 #15
0
 public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   hostGraphics.fillArc(x, y, width, height, startAngle, arcAngle);
 }
コード例 #16
0
 /* (non-Javadoc)
  * @see org.apache.wicket.markup.html.image.resource.RenderedDynamicImageResource#render(java.awt.Graphics2D)
  */
 @Override
 protected boolean render(Graphics2D graphics) {
   graphics.setColor(getColor());
   graphics.fillArc(0, -15, 30, 30, 180, 90);
   return true;
 }
コード例 #17
0
ファイル: FTACanvas.java プロジェクト: jandcmoore/OpenFTA
 private void clearArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   penColor = gRef.getColor();
   gRef.setColor(Preferences.backgroundColor);
   gRef.fillArc(x, y, width, height, startAngle, arcAngle);
   gRef.setColor(penColor);
 }