示例#1
0
	public void paint(Graphics g){ //Graphics is a crayon box; Graphics2d is like an art kit
		BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_ARGB);
		Graphics2D g2 = (Graphics2D)image.getGraphics();
		//Graphics2D g2 = (Graphics2D)g;
		g2.setColor(Color.white);
		g2.fillRect(0,0,width,height);
		g2.setColor(Color.pink);
		g2.drawOval(50, 50, width-100, height-100);
		g2.drawOval(175, 175, width-490, height-490);
		g2.drawOval(375, 175, width-490, height-490);
		g2.drawLine(0,10,height,0);
		g2.drawArc(175, 250, 250, 130, 200, 90);
		Hero hero2 = new Hero("Dorami", "/images/heroes/Dorami.jpg",100,100);

		if(Math.abs(hero1.getX()-hero2.getX()) + Math.abs(hero1.getY()-hero2.getY()) <20  ){
			itemPickedUp=true;
		}
		if(!itemPickedUp){g2.drawImage(hero2.getImage(), hero2.getX(), hero2.getY(), null);}
		g2.drawImage(hero1.getImage(), hero1.getX(), hero1.getY(), null);
		//g2.fillOval(50,100,200,100);
		//g2.drawArc(50, 300, 200, 100,0,90);
	/*	int c =0;
		int margin =2;
		int squareD =20;
		for(int x=0; x<width; x+= squareD +margin){
			for(int y=0; y<height; y+= squareD+margin){
				if(c<255) c++;
				else c=0;
				Color local = new Color((int) Math.floor(Math.random() * 256),(int) Math.floor(Math.random() * 256),c);
				g2.setColor(local);
				g2.fillRect(x,y,squareD,squareD);
			}
		}*/
		g.drawImage(image, 0, 0, null);
	}
 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);
 }
  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);
      }
    }
  }
示例#4
0
    /**
     * draw
     *
     * @param g graphics
     * @param x x
     * @param y y
     * @param width width
     * @param height height
     * @param speed wind speed
     * @param dirDegrees wind dir
     */
    public void draw(
        Graphics2D g, int x, int y, int width, int height, double speed, double dirDegrees) {

      this.windSpeed = speed;
      this.x0 = x0;
      this.y0 = y0;
      double theta = dirDegrees * DEG_TO_RAD;
      sint = Math.sin(theta);
      cost = Math.cos(theta);

      x0 = x + width / 2;
      y0 = y + height / 2;

      // calc how long the windBarb should be
      int len = 0;
      while (speed >= 47.5) {
        len += 6;
        speed -= 50;
      }
      while (speed >= 7.5) {
        len += 3;
        speed -= 10;
      }
      if (speed >= 2.5) {
        len += 3;
      }
      lenBarb = Math.max(len, width);

      // special case : calm
      if (windSpeed < 0.5) {
        int radius = 10;
        g.drawArc(x0 - radius / 2, y0 - radius / 2, radius, radius, 0, 360);
        return;
      } else {
        drawRotatedLine(g, 0, 0, 0, -lenBarb);
      }

      // draw the flags and lines
      int start = 0;
      speed = windSpeed;
      while (speed >= 47.5) {
        start = draw50knotFlag(g, start);
        speed -= 50;
      }
      while (speed >= 7.5) {
        start = draw10knotLine(g, start);
        speed -= 10;
      }
      if (speed >= 2.5) {
        if ((windSpeed >= 2.5) && (windSpeed < 7.5)) { // special case
          start = 3;
        }
        drawRotatedBarbLine(g, 0, -lenBarb + start, .2 * lenBarb, -lenBarb + start - 1.5);
      }
    }
示例#5
0
  public static void drawStandardLoop(Graphics2D g2, int x, int y) {
    g2.setStroke(BPMNUtils.defaultStroke);
    g2.drawArc(
        x - MARKER_ICON_SIZE / 2,
        y - MARKER_ICON_SIZE / 2,
        MARKER_ICON_SIZE,
        MARKER_ICON_SIZE,
        315,
        270);

    g2.drawLine(x, y, x, y + MARKER_ICON_SIZE / 2);
    g2.drawLine(x, y + MARKER_ICON_SIZE / 2, x + MARKER_ICON_SIZE / 2, y + MARKER_ICON_SIZE / 2);
  }
示例#6
0
  private void drawWaveAndMae(GBulletFiredEvent wave, Graphics2D g) {
    double maeLength = 300;
    double radius = wave.getVelocity() * (getTime() - wave.getFiringTime());
    g.drawArc(
        (int) (wave.getFiringPosition().getX() - radius),
        (int) (wave.getFiringPosition().getY() - radius),
        (int) radius * 2,
        (int) radius * 2,
        0,
        360);
    g.drawRect(
        (int) wave.getFiringPosition().getX() - 5,
        (int) wave.getFiringPosition().getY() - 5,
        10,
        10);

    double absBearing =
        org.pattern.utils.Utils.absBearing(wave.getFiringPosition(), wave.getTargetPosition());

    drawPoint(wave.getFiringPosition(), 4, g);
    drawPoint(wave.getTargetPosition(), 4, g);
    // //draw MAE
    g.drawLine(
        (int) wave.getFiringPosition().getX(),
        (int) wave.getFiringPosition().getY(),
        (int) (wave.getTargetPosition().getX()),
        (int) (wave.getTargetPosition().getY()));

    g.drawLine(
        (int) wave.getFiringPosition().getX(),
        (int) wave.getFiringPosition().getY(),
        (int)
            (wave.getFiringPosition().getX()
                + Math.sin(Math.toRadians(absBearing + wave.getMaxMAE())) * maeLength),
        (int)
            (wave.getFiringPosition().getY()
                + Math.cos(Math.toRadians(absBearing + wave.getMaxMAE())) * maeLength));

    g.drawLine(
        (int) wave.getFiringPosition().getX(),
        (int) wave.getFiringPosition().getY(),
        (int)
            (wave.getFiringPosition().getX()
                + Math.sin(Math.toRadians(absBearing + wave.getMinMAE())) * maeLength),
        (int)
            (wave.getFiringPosition().getY()
                + Math.cos(Math.toRadians(absBearing + wave.getMinMAE())) * maeLength));
  }
示例#7
0
  @Override
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2d = (Graphics2D) g;
    // g2d.setPaint(new GradientPaint(x, y, new Color(30, 145, 140), x, y + s, new Color(35, 185,
    // 185)));
    g2d.setStroke(new BasicStroke(2));

    if (mode == 0) {
      end = angle + step;
      g2d.setColor(new Color(15, 125, 125, 100));
      g2d.drawArc(x, y, s, s, 96 - (int) angle, 347 - (int) (step));
      g2d.setColor(new Color(35, 185, 185));
      g2d.drawArc(x, y, s, s, 90 - (int) (angle), (int) (angle - end));
    } else if (mode == 1) {
      g2d.setColor(new Color(15, 125, 125, 100));
      g2d.drawArc(x, y, s, s, 96 - (int) angle, 347 - (int) (step + end));
      g2d.setColor(new Color(35, 185, 185));
      g2d.drawArc(x, y, s, s, 90 - (int) (angle), (int) (angle - step) - 1);
      g2d.setColor(new Color(35, 185, 185, 160));
      g2d.drawArc(x, y, s, s, 82 - (int) (angle + step), (int) (angle - end) + 8);
    } else {
      float empty = 0;
      for (int i = 0; i < colors.length; i++) {
        if (dist.length > i) {
          empty += dist[i];
          g2d.setColor(colors[i]);
          g2d.setStroke(new BasicStroke(2));
          g2d.drawArc(x, y, s, s, 90 - (int) empty, (int) dist[i] - 2);
          g2d.setStroke(new BasicStroke(1));
          g2d.drawArc(x + 4, y + 4, s - 8, s - 8, 90 - (int) empty, (int) dist[i] - 2);
        }
      }
      g2d.setColor(new Color(15, 125, 125, 100));
      g2d.setStroke(new BasicStroke(2));
      g2d.drawArc(x, y, s, s, 91, (int) (357 - empty));
      g2d.setStroke(new BasicStroke(1));
      g2d.drawArc(x + 4, y + 4, s - 8, s - 8, 91, (int) (357 - empty));
    }
  }
  public static void drawRound3DBorder(Graphics g, Color c1, Color c2, int x, int y, int w, int h) {
    Graphics2D g2D = (Graphics2D) g;
    int x2 = x + w;
    int y2 = y + h;
    int d = h;
    int r = h / 2;
    Color cm = ColorHelper.median(c1, c2);
    Color c1m = ColorHelper.median(c1, cm);
    Color c2m = ColorHelper.median(c2, cm);

    Object savedRederingHint = g2D.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
    g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    // oben
    g2D.setColor(c1);
    g2D.drawLine(x + r, y, x2 - r, y);
    // rechts
    g2D.drawLine(x, y + r, x, y2 - r);
    // unten
    g2D.setColor(c2);
    g2D.drawLine(x + r, y2, x2 - r, y2);
    // links
    g2D.drawLine(x2, y + r, x2, y2 - r);

    // links
    g2D.setColor(c1);
    g2D.drawArc(x, y, d, d, 90, 45);
    g2D.setColor(c1m);
    g2D.drawArc(x, y, d, d, 135, 45);
    g2D.setColor(cm);
    g2D.drawArc(x, y, d, d, 180, 45);
    g2D.setColor(c2m);
    g2D.drawArc(x, y, d, d, 225, 45);
    // rechts
    g2D.setColor(c1m);
    g2D.drawArc(x2 - d, y, d, d, 45, 45);
    g2D.setColor(cm);
    g2D.drawArc(x2 - d, y, d, d, 0, 45);
    g2D.setColor(c2m);
    g2D.drawArc(x2 - d, y, d, d, -45, 45);
    g2D.setColor(c2);
    g2D.drawArc(x2 - d, y, d, d, -90, 45);
    g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, savedRederingHint);
  }
 public void paintOnTreePanel(TreeViewPanel panel, Graphics2D canvas) {
   TreeView view = panel.t;
   for (TreeViewNode n : view.treeNodes.values()) {
     int childID = n.id;
     if (forwardLinks.getData(childID) != null) {
       int forwardID = forwardLinks.getData(childID);
       TreeViewNode forward = view.treeNodes.get(forwardID);
       if (forward != null) {
         if (n.getEdgeDir().equals("sel")) {
           canvas.setColor(nodeColorings.get(childID));
         } else {
           canvas.setColor(Color.LIGHT_GRAY);
         }
         if (forward.y > n.y) {
           TreeViewNode temp = forward;
           forward = n;
           n = temp;
         }
         int c = 80;
         int a = Math.abs(n.x - forward.x) + c;
         int x = Math.abs(n.x - forward.x);
         int y = n.y - forward.y;
         int b = y / 2;
         if (x != 0) {
           b = (int) (((a - Math.sqrt(a * a - x * x)) * y * a) / (x * x));
         }
         int arcAngle = 180;
         if (x != 0) {
           arcAngle =
               (int)
                   Math.round(
                       (Math.atan((double) (y - b) / ((x / (x + 50.0)) * b)) * 180) / Math.PI);
           if (forward.x - n.x < 0) {
             arcAngle = 270 - arcAngle;
           } else {
             arcAngle += 90;
           }
         }
         canvas.drawArc(forward.x - a, forward.y, 2 * a, 2 * b, 90 + arcAngle, 360 - arcAngle);
       }
     }
   }
 }
 public void draw(Graphics2D g2, float x, float y) {
   AffineTransform oldAt = g2.getTransform();
   Color oldC = g2.getColor();
   Stroke oldS = g2.getStroke();
   g2.translate(x + 0.25f * height / 2.15f, y - 1.75f / 2.15f * height);
   g2.setColor(gray);
   g2.setStroke(st);
   g2.scale(0.05f * height / 2.15f, 0.05f * height / 2.15f);
   g2.rotate(-26 * Math.PI / 180, 20.5, 17.5);
   g2.drawArc(0, 0, 43, 32, 0, 360);
   g2.rotate(26 * Math.PI / 180, 20.5, 17.5);
   g2.setStroke(oldS);
   drawCircle(g2, 16f, -5f);
   drawCircle(g2, -1f, 7f);
   drawCircle(g2, 5f, 28f);
   drawCircle(g2, 27f, 24f);
   drawCircle(g2, 36f, 3f);
   g2.setStroke(oldS);
   g2.setTransform(oldAt);
   g2.setColor(oldC);
 }
 public void paintIcon(Component c, Graphics graphics, int x, int y) {
   Font font = UIManager.getFont("TextField.font");
   Graphics2D g = (Graphics2D) graphics.create(x, y, getIconWidth(), getIconHeight());
   g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   g.setRenderingHint(
       RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
   g.setFont(font.deriveFont(Font.BOLD, getIconWidth() * 3 / 4));
   g.setColor(Color.green.darker());
   final int SW = Math.max(getIconWidth() / 10, 4);
   g.setStroke(new BasicStroke(SW));
   g.drawArc(SW / 2, SW / 2, getIconWidth() - SW - 1, getIconHeight() - SW - 1, 0, 360);
   Rectangle2D bounds = font.getStringBounds("i", g.getFontRenderContext());
   g.drawString(
       "i",
       Math.round((getIconWidth() - bounds.getWidth()) / 2 - getIconWidth() / 12),
       SW / 2
           + Math.round(
               (getIconHeight() - bounds.getHeight()) / 2
                   - bounds.getY()
                   + getIconHeight() / 8));
   g.dispose();
 }
示例#12
0
  private void doDrawing(Graphics g) throws InterruptedException {

    Graphics2D g2d = (Graphics2D) g;

    g2d.setColor(Color.blue);

    Dimension size = getSize();
    Insets insets = getInsets();

    int w = size.width - insets.left - insets.right;
    int h = size.height - insets.top - insets.bottom;

    Random generator = new Random();
    double[][] center = new double[NCLUSTERS][DIMENSION];

    String inFilenamec = "/home/cloudera/workspace/training/datasource/center";
    try {

      BufferedReader bwc = new BufferedReader(new FileReader(inFilenamec));
      String line;
      for (int i = 0; i < NCLUSTERS; i++) {
        line = bwc.readLine();
        String[] num = line.split(" ");
        center[i][0] = Double.parseDouble(num[0]);
        center[i][1] = Double.parseDouble(num[1]);
      }
      bwc.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    String inFilename = "/home/cloudera/workspace/training/datasource/kmean";

    try {
      BufferedReader bw = new BufferedReader(new FileReader(inFilename));
      String line;

      for (int K = 0; K < 100; K++) {
        for (int i = 0; i < NCLUSTERS; i++) {
          line = bw.readLine();
          String[] num = line.split(" ");
          double dx = Double.parseDouble(num[0]);
          double dy = Double.parseDouble(num[1]);
          g2d.setColor(Color.GREEN);
          int sP = 3;
          int x = (int) Math.abs(Math.round(dx * (w - 7))) + 3;
          int y = (int) Math.abs(Math.round(dy * (h - 7))) + 3;
          g2d.drawLine(x - sP, y, x + sP, y);
          g2d.drawLine(x, y - sP, x, y + sP);
        }
      }
      bw.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("Done");
    g2d.setColor(Color.RED);
    for (int i = 0; i < NCLUSTERS; i++) {
      double dx = center[i][0];
      double dy = center[i][1];
      int x = (int) Math.abs(Math.round(dx * w)) % w;
      int y = (int) Math.abs(Math.round(dy * h)) % h;
      g2d.drawArc(x - 5, y - 5, 11, 11, 0, 360);
    }
    double[][] precenter = new double[NCLUSTERS][DIMENSION];
    for (int i = 0; i < NCLUSTERS; i++) {
      for (int j = 0; j < DIMENSION; j++) {
        precenter[i][j] = ((double) (i + 1)) / (NCLUSTERS + 1);
        ;
      }
      double dx = precenter[i][0];
      double dy = precenter[i][1];
      int x = (int) Math.abs(Math.round(dx * w)) % w;
      int y = (int) Math.abs(Math.round(dy * h)) % h;
      g2d.drawRect(x - 4, y - 4, 9, 9);
    }

    g2d.setColor(Color.BLUE);
    String outFilenamepre = "/home/cloudera/workspace/training/dataoutput/";
    for (int k = 1; k < 20; k++) {
      String outFilename = outFilenamepre + "iteration" + k + "/part-00000";
      try {
        BufferedReader bwo = new BufferedReader(new FileReader(outFilename));
        String line;
        for (int i = 0; i < NCLUSTERS; i++) {
          line = bwo.readLine();
          String[] num = line.split(" ");
          String[] num0 = num[0].split("	");
          System.out.println("num[0]=" + num[0] + " line =" + num0[1]);
          double dxp = precenter[i][0];
          double dyp = precenter[i][1];
          int xp = (int) Math.abs(Math.round(dxp * w)) % w;
          int yp = (int) Math.abs(Math.round(dyp * h)) % h;
          double dx = Double.parseDouble(num0[1]);
          double dy = Double.parseDouble(num[1]);

          int x = (int) Math.abs(Math.round(dx * w)) % w;
          int y = (int) Math.abs(Math.round(dy * h)) % h;
          g2d.drawLine(xp, yp, x, y);
          g2d.drawRect(x - 4, y - 4, 9, 9);
          precenter[i][0] = dx;
          precenter[i][1] = dy;
        }
        // wait(1000);
        bwo.close();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    } // k
  }
 public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   hostGraphics.drawArc(x, y, width, height, startAngle, arcAngle);
 }
示例#14
0
 // 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);
   }
 }
示例#15
0
 @Override
 protected void paintFoldShape(Graphics2D gfx, int top, int bottom) {
   gfx.drawArc(1, top, 8, (bottom - top), 0, 360);
 }
示例#16
0
 private void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   gRef.drawArc(x, y, width, height, startAngle, arcAngle);
 }
示例#17
0
  public void renderPlot(Graphics2D g) {

    g.setColor(Color.RED);

    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    int xCenter = getCenterX();
    int yCenter = getCenterY();

    // g.drawRect(0, 0, xCenter, yCenter);
    // g.drawRect(0, 0, this.getDimension().width,
    // this.getDimension().height);

    DataModel1D model1 = (DataModel1D) this.getDataModel();
    double total = getTotalValue().doubleValue();

    int stop = model1.getSize();

    computeColorsAndSpaces();
    // spaces[0] = 10;
    int maxSpace = (int) spaces[0];

    int height2 = Math.min(xCenter, yCenter) - maxSpace - this.getMaxLabelHeight(g) / 2 - 2;
    int width2 = height2; // Math.min(xCenter, yCenter) - maxSpace;
    int posX = (getCenterX() - width2);
    int posY = (getCenterY() - width2);
    double ratio = 360 / total;
    double startAngle = 0D;
    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 + width2 / 2 + (int) ((Math.cos(angleRadian)) * current_space);
      int y = posY + height2 / 2 + (int) ((-Math.sin(angleRadian)) * current_space);

      g.setColor(colors[i]);
      g.setStroke(
          new BasicStroke(
              width2 - this.innerWidth,
              BasicStroke.CAP_BUTT,
              BasicStroke.JOIN_MITER,
              12.0f,
              null,
              10.0f));
      g.drawArc(x, y, width2, height2, (int) Math.round(startAngle), -angle);

      g.setStroke(new BasicStroke());
      if (i < labels.size()) {
        final String label = labels.get(i).getLabel();
        int x1 =
            width2 + posX + (int) Math.round((Math.cos(angleRadian)) * (width2 + current_space));
        int y1 =
            height2 + posY + (int) Math.round((-Math.sin(angleRadian)) * (height2 + current_space));
        int x2 =
            width2
                + posX
                + (int) Math.round((Math.cos(angleRadian)) * (width2 + current_space + 3));
        int y2 =
            height2
                + posY
                + (int) Math.round((-Math.sin(angleRadian)) * (height2 + current_space + 3));
        g.setColor(Color.GRAY);
        g.drawLine(x1, y1, x2, y2);
        int x3;
        int xLabel;
        int y4 = y2 + g.getFontMetrics().getAscent() / 2 - 2;
        if (x1 > xCenter) {
          // Label a droite
          x3 = x2 + 2 + (this.getChartRectangle().width - x1) / 2;
          xLabel = x3 + 2;

          if (x3 + getLabelWidth(g, label) > this.getChartRectangle().getWidth()) {
            // Pas assez de place, besoin de decaler à gauche le label de droite
            x3 = (int) this.getChartRectangle().getWidth() - getLabelWidth(g, label) - 4;
            xLabel = x3 + 4;
          }

        } else {
          // Label à gauche
          x3 = x2;
          x2 = (xCenter - width2) / 2;
          xLabel = x2 - this.getMaxLabelWidth(g) - 2;

          if (xLabel < 0) {
            xLabel = 0;
            x2 = getLabelWidth(g, label);
          }
        }

        // ligne horizontale partant de la gauche vers la droite
        if (x2 < x3) {

          g.drawLine(x2, y2, x3, y2);
        }
        // if (xLabel < 0) {
        // xLabel = 0;
        // }
        g.drawString(label, xLabel, y4);
      }
      startAngle -= angle;
    }

    if (this.getSeparatorColor() != null) {
      startAngle = 0D;
      g.setStroke(new BasicStroke(2f));
      g.setColor(this.getSeparatorColor());
      // g.setColor(Color.RED);
      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 angleRadian = ((startAngle) * Math.PI * 2) / 360;
        double current_space = spaces[i];

        // int x1 = posX + width2 + (int)
        // Math.round((Math.cos(angleRadian)) * (current_space+1);
        // int y1 = posY + height2 + (int)
        // Math.round((-Math.sin(angleRadian)) * (current_space+1);
        int x2 = posX + width2 + (int) ((Math.cos(angleRadian)) * (width2 + current_space + 2));
        int y2 = posY + height2 + (int) ((-Math.sin(angleRadian)) * (height2 + current_space + 2));
        g.drawLine(xCenter, yCenter, x2, y2);
        startAngle -= angle;
      }
    }
    // renderInner(g, width2, height2, spaces);

  }
示例#18
0
  @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);
  }
示例#19
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;
      }
    }
  }
示例#20
0
 public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
   g2d.drawArc(x, y, width, height, startAngle, arcAngle);
 }