Example #1
0
	/**
	 * @param g2
	 * @throws IOException
	 */
	private void drawNode(Map<String, Node> nodes, Graphics2D g2, Font font) throws IOException {
		for (Node node : nodes.values()) {
			String name = node.getName();
			if (nodeInfos.get(node.getType()) != null) {
				BufferedImage bi2 = ImageIO.read(getClass().getResourceAsStream(
						"icons/48/" + nodeInfos.get(node.getType())));
				g2.drawImage(bi2, node.getX(), node.getY(), null);
			} else {
				int x = node.getX();
				int y = node.getY();
				int w = node.getWitdth();
				int h = node.getHeight();
				g2.setColor(DEFAULT_FILL_COLOR);
				g2.fillRoundRect(x, y, w, h, RECT_ROUND, RECT_ROUND);
				g2.setColor(DEFAULT_STROKE_COLOR);
				g2.setStroke(DEFAULT_STROKE);
				g2.drawRoundRect(x, y, w, h, RECT_ROUND, RECT_ROUND);

				FontRenderContext frc = g2.getFontRenderContext();
				Rectangle2D r2 = font.getStringBounds(name, frc);
				int xLabel = (int) (node.getX() + ((node.getWitdth() - r2.getWidth()) / 2));
				int yLabel = (int) ((node.getY() + ((node.getHeight() - r2.getHeight()) / 2)) - r2.getY());
				g2.setStroke(DEFAULT_LINE_STROKE);
				g2.setColor(Color.black);
				g2.drawString(name, xLabel, yLabel);
			}
		}
	}
    /**
     * Hook for subclassers to paint the background page(s).
     *
     * @param g2 The graphics object to paint the background page(s) on.
     */
    protected void paintBackgroundPages(Graphics2D g2) {
      Point2D p = graph.toScreen(new Point2D.Double(pageFormat.getWidth(), pageFormat.getHeight()));
      Dimension pSize = graph.getPreferredSize();
      int w = (int) (p.getX() * pageScale);
      int h = (int) (p.getY() * pageScale);
      int cols = (int) Math.max(Math.ceil((double) (pSize.width - 5) / (double) w), 1);
      int rows = (int) Math.max(Math.ceil((double) (pSize.height - 5) / (double) h), 1);
      g2.setColor(graph.getHandleColor());

      // Draws the pages.
      Point offset = getViewPosition();
      g2.translate(-offset.x, -offset.y);
      g2.fillRect(0, 0, graph.getWidth(), graph.getHeight());
      g2.setColor(Color.darkGray);
      g2.fillRect(3, 3, cols * w, rows * h);
      g2.setColor(getGraph().getBackground());
      g2.fillRect(1, 1, cols * w - 1, rows * h - 1);

      // Draws the pagebreaks.
      Stroke previousStroke = g2.getStroke();
      g2.setStroke(
          new BasicStroke(
              1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, new float[] {1, 2}, 0));
      g2.setColor(Color.darkGray);
      for (int i = 1; i < cols; i++) g2.drawLine(i * w, 1, i * w, rows * h - 1);
      for (int i = 1; i < rows; i++) g2.drawLine(1, i * h, cols * w - 1, i * h);

      // Restores the graphics.
      g2.setStroke(previousStroke);
      g2.translate(offset.x, offset.y);
      g2.clipRect(0, 0, cols * w - 1 - offset.x, rows * h - 1 - offset.y);
    }
  @Override
  protected void paintComponent(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    Rectangle b = getBounds();

    // dessiner un fond de couleur
    Color bgColor = color != null ? color : Color.white;
    g2d.setColor(bgColor);
    g2d.fillRect(0, 0, b.width, b.height);

    // si la couleur est nulle, dessiner une diagonale
    if (color == null) {
      g2d.setColor(borderColor);
      g2d.setStroke(new BasicStroke(borderThickness + 1));
      g2d.drawLine(0, 0, b.width, b.height);
    }

    // bordure
    g2d.setStroke(new BasicStroke(borderThickness));
    g2d.setColor(borderColor);
    g2d.drawRect(
        borderThickness / 2,
        borderThickness / 2,
        b.width - borderThickness,
        b.height - borderThickness);
  }
Example #4
0
  private void drawShape(Shuttle shuttle) {
    Graphics2D g = shuttle.g;
    Shape oldclip = shuttle.g.getClip();
    g.setClip(shuttle.clip);
    Composite oldcomposite = g.getComposite();
    if (shuttle.opacity != 1f) {
      g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, shuttle.opacity));
    }

    AffineTransform oldtr = g.getTransform();
    g.setTransform(shuttle.transform);

    Stroke oldStroke = g.getStroke();
    Stroke newStroke =
        new BasicStroke(shuttle.strokeWidth, shuttle.linecap.stroke(), shuttle.linejoin.stroke());
    g.setStroke(newStroke);

    if (shuttle.fill != null) {
      g.setPaint(shuttle.fill);
      g.fill(shuttle.shape);
    }
    if (shuttle.stroke != null) {
      g.setPaint(shuttle.stroke);
      g.draw(shuttle.shape);
    }
    g.setClip(oldclip);
    g.setStroke(oldStroke);
    g.setTransform(oldtr);
    g.setComposite(oldcomposite);
  }
  public void drawExclusiveGateway(int x, int y, int width, int height) {
    // rhombus
    drawGateway(x, y, width, height);

    int quarterWidth = width / 4;
    int quarterHeight = height / 4;

    // X inside rhombus
    Stroke orginalStroke = g.getStroke();
    g.setStroke(GATEWAY_TYPE_STROKE);
    Line2D.Double line =
        new Line2D.Double(
            x + quarterWidth + 3,
            y + quarterHeight + 3,
            x + 3 * quarterWidth - 3,
            y + 3 * quarterHeight - 3);
    g.draw(line);
    line =
        new Line2D.Double(
            x + quarterWidth + 3,
            y + 3 * quarterHeight - 3,
            x + 3 * quarterWidth - 3,
            y + quarterHeight + 3);
    g.draw(line);

    g.setStroke(orginalStroke);
  }
  private void showScale(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    g2d.setColor(Color.lightGray);
    int y_step = 20;
    float[] dash1 = {2f, 0f, 2f};

    Stroke strk = g2d.getStroke();

    g2d.setStroke(
        new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash1, 2f));
    for (int y = m_y_offset - y_step; y > m_y_offset - (int) (m_height * 0.5); y -= y_step)
      g2d.drawLine(m_x_offset, y, m_width - m_x_offset, y);
    for (int y = m_y_offset + y_step; y < m_y_offset + (int) (m_height * 0.5); y += y_step)
      g2d.drawLine(m_x_offset, y, m_width - m_x_offset, y);

    for (int x = m_x_offset + y_step; x < m_width - m_x_offset; x += y_step)
      g2d.drawLine(x, m_y_offset - (int) (m_height * 0.5), x, m_y_offset + (int) (m_height * 0.5));

    Font cur_Font = new Font("Arial", Font.BOLD, 8);
    g.setFont(cur_Font);

    int i = y_step;
    for (int y = m_y_offset - y_step;
        y > m_y_offset - (int) (m_height * 0.5);
        y -= y_step, i += y_step) g.drawString(i + "", m_width - m_x_offset, y);
    i = -y_step;
    for (int y = m_y_offset + y_step;
        y < m_y_offset + (int) (m_height * 0.5);
        y += y_step, i -= y_step) g.drawString(i + "", m_width - m_x_offset, y);

    g2d.setStroke(strk);
  }
Example #7
0
  private void drawSelectionBox(Graphics2D g2d) {

    // Draw the rectangular selection box
    if (leftMousePressed && !startedInMiniMap && !startedInHiveCreation) {

      Pt topLeft = new Pt();
      topLeft.setX(Math.min(mouseGlobal.x(), startSelect.x()));
      topLeft.setY(Math.min(mouseGlobal.y(), startSelect.y()));

      int width = (int) Math.abs(mouseGlobal.x() - startSelect.x());
      int height = (int) Math.abs(mouseGlobal.y() - startSelect.y());

      g2d.setColor(Color.GREEN);
      Stroke original = g2d.getStroke();
      int dashOneLength = 3;
      int dashInterval = 5;
      int dashTwoLength = dashOneLength * 5;
      g2d.setStroke(
          new BasicStroke(
              1,
              BasicStroke.CAP_BUTT,
              BasicStroke.JOIN_BEVEL,
              0,
              new float[] {dashOneLength, dashInterval, dashTwoLength, dashInterval},
              0));
      g2d.drawRect(topLeft.intX(), topLeft.intY(), width, height);
      g2d.setStroke(original);
    }
  }
Example #8
0
  /**
   * Draws the circle.
   *
   * @param g2 the graphics device.
   * @param area the area in which to draw.
   */
  public void draw(Graphics2D g2, Rectangle2D area) {
    Ellipse2D ellipse =
        new Ellipse2D.Double(
            area.getX(), area.getY(),
            area.getWidth(), area.getHeight());
    if (this.fillPaint != null) {
      g2.setPaint(this.fillPaint);
      g2.fill(ellipse);
    }
    if (this.outlinePaint != null && this.outlineStroke != null) {
      g2.setPaint(this.outlinePaint);
      g2.setStroke(this.outlineStroke);
      g2.draw(ellipse);
    }

    g2.setPaint(Color.black);
    g2.setStroke(new BasicStroke(1.0f));
    Line2D line1 =
        new Line2D.Double(
            area.getCenterX(), area.getMinY(),
            area.getCenterX(), area.getMaxY());
    Line2D line2 =
        new Line2D.Double(
            area.getMinX(), area.getCenterY(),
            area.getMaxX(), area.getCenterY());
    g2.draw(line1);
    g2.draw(line2);
  }
Example #9
0
  // Actually draws the rectangle
  public void draw(Graphics g) {
    Graphics2D g2 = (Graphics2D) g; // create a Graphics2D object

    if (getGradient()) {
      GradientPaint gradientPaint =
          new GradientPaint(
              getUpperLeftX(),
              getUpperLeftY(),
              getColor(),
              getUpperLeftX() + getWidth(),
              getUpperLeftY() + getHeight(),
              getColor2());
      g2.setPaint(gradientPaint);
    } else g2.setPaint(getColor());

    if (getDashed()) {
      float dash1[] = {10.0f};
      BasicStroke dashedLine =
          new BasicStroke(
              getDashLength(), BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f);
      g2.setStroke(dashedLine);
    } else {
      g2.setStroke(new BasicStroke(getStrokeWidth()));
    }

    if (getFilledF())
      g2.fill(new Rectangle2D.Double(getUpperLeftX(), getUpperLeftY(), getWidth(), getHeight()));
    else g2.draw(new Rectangle2D.Double(getUpperLeftX(), getUpperLeftY(), getWidth(), getHeight()));
  }
Example #10
0
  @Override
  public void paint(
      final Graphics2D g,
      final Rectangle srcRect,
      final double magnification,
      final boolean active,
      final int channels,
      final Layer active_layer,
      final List<Layer> layers) {
    AffineTransform gt = null;
    Stroke stroke = null;
    AffineTransform aff = this.at;
    // remove graphics transform
    if (!"true".equals(getProject().getProperty("dissector_zoom"))) {
      gt = g.getTransform();
      g.setTransform(new AffineTransform()); // identity
      stroke = g.getStroke();
      g.setStroke(new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER));
      aff = new AffineTransform(gt);
      aff.concatenate(this.at);
    }

    for (final Item item : al_items) {
      item.paint(g, aff, active_layer);
    }

    // restore
    if (null != gt) g.setTransform(gt);
    if (null != stroke) g.setStroke(stroke);
  }
Example #11
0
  /**
   * Draws an arc.
   *
   * @param g2 the graphics device.
   * @param area the plot area.
   * @param minValue the minimum value.
   * @param maxValue the maximum value.
   * @param paint the paint.
   * @param stroke the stroke.
   */
  protected void drawArc(
      Graphics2D g2,
      Rectangle2D area,
      double minValue,
      double maxValue,
      Paint paint,
      Stroke stroke) {

    double startAngle = valueToAngle(maxValue);
    double endAngle = valueToAngle(minValue);
    double extent = endAngle - startAngle;

    double x = area.getX();
    double y = area.getY();
    double w = area.getWidth();
    double h = area.getHeight();
    g2.setPaint(paint);
    g2.setStroke(stroke);

    if (paint != null && stroke != null) {
      Arc2D.Double arc = new Arc2D.Double(x, y, w, h, startAngle, extent, Arc2D.OPEN);
      g2.setPaint(paint);
      g2.setStroke(stroke);
      g2.draw(arc);
    }
  }
  /** Paints selection for the specified <code>component</code>. */
  public static void paintSelectionDecoration(
      @NotNull RadComponent component, Graphics g, boolean focused) {
    if (component.isSelected()) {
      if (focused) {
        g.setColor(PlatformColors.BLUE);
      } else {
        g.setColor(Color.GRAY);
      }
      final Point[] points = getPoints(component.getWidth(), component.getHeight());
      for (final Point point : points) {
        g.fillRect(point.x - R, point.y - R, 2 * R + 1, 2 * R + 1);
      }
    } else if (component.getWidth() < FormEditingUtil.EMPTY_COMPONENT_SIZE
        || component.getHeight() < FormEditingUtil.EMPTY_COMPONENT_SIZE) {
      Graphics2D g2d = (Graphics2D) g;
      Composite oldComposite = g2d.getComposite();
      Stroke oldStroke = g2d.getStroke();
      Color oldColor = g2d.getColor();

      g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 0.5f));
      g2d.setStroke(new BasicStroke(0.7f));
      g2d.setColor(Color.black);
      g2d.drawRect(
          0,
          0,
          Math.max(component.getWidth(), FormEditingUtil.EMPTY_COMPONENT_SIZE),
          Math.max(component.getHeight(), FormEditingUtil.EMPTY_COMPONENT_SIZE));

      g2d.setComposite(oldComposite);
      g2d.setStroke(oldStroke);
      g2d.setColor(oldColor);
    }
  }
Example #13
0
    @Override
    public void paint(Graphics2D g) {

      g.setColor(Color.BLACK);
      for (NodeView view : nodes) {
        Node<String> node = view.getNode();
        for (NodeView other : nodes) {
          Node<String> otherNode = other.getNode();
          if (graph.connected(node, otherNode)) {
            Line2D l2d = new Line2D.Double(view.getX(), view.getY(), other.getX(), other.getY());
            // stroke width asymptotically approaches 10
            // 10 (1 - r^(w/k))
            // w = weight
            // r = convergence time
            // k = scalar for weight

            // find edge
            Set<? extends WeightedEdge<String, Double>> neighboringEdges =
                graph.getNeighboringEdges(node);
            for (WeightedEdge<String, Double> edge : neighboringEdges) {
              if (edge.getTail() == otherNode) {
                Color headColor = mst != null && mst.contains(edge) ? Color.RED : Color.BLACK;

                Color tailColor =
                    (edge instanceof DirectedEdge)
                        ? new Color(headColor.getRGB() & 0x1FFFFFFF, true)
                        : headColor;
                g.setPaint(
                    new GradientPaint(
                        new Point2D.Double(view.getX(), view.getY()), headColor,
                        new Point2D.Double(other.getX(), other.getY()), tailColor));

                float width =
                    (float)
                        (10
                            * (1f
                                - Math.pow(
                                    0.8f,
                                    Math.abs(edge.getWeight())
                                        / (settings.useDistanceWeight ? 6f : 3f))));
                if (edge.getWeight() >= 0) {
                  g.setStroke(new BasicStroke(width));
                } else {
                  g.setStroke(
                      new BasicStroke(
                          width,
                          BasicStroke.CAP_BUTT,
                          BasicStroke.JOIN_ROUND,
                          10.0f,
                          new float[] {width * 4},
                          0));
                }
              }
            }
            g.draw(l2d);
          }
        }
        super.paint(g);
      }
    }
  private void plot(Graphics2D g, Material material, Shape shape, boolean subdued) {
    final Stroke savedStroke = g.getStroke();
    g.setStroke(plotStroke);
    double yTensile = Inventory.tensileStrength(material, shape);
    final int iy = yPlotAreaBottom - (int) Math.round((yTensile / yMax) * heightPlotArea);
    g.setColor(subdued ? subduedBlue : Color.BLUE);
    g.drawLine(xPlotAreaLeft, iy, xPlotAreaRight, iy);

    final int nPlotPoints = 32;
    double yCompressive = Inventory.compressiveStrength(material, shape, 0.0);
    int iy0 = yPlotAreaBottom - (int) Math.round((yCompressive / yMax) * heightPlotArea);
    int ix0 = xPlotAreaLeft;
    g.setColor(subdued ? subduedRed : Color.RED);
    for (int i = 1; i <= nPlotPoints; i++) {
      double t = (double) i / nPlotPoints;
      double x = t * xMax;
      int ix1 = xPlotAreaLeft + (int) Math.round(t * widthPlotArea);
      yCompressive = Inventory.compressiveStrength(material, shape, x);
      int iy1 = yPlotAreaBottom - (int) Math.round((yCompressive / yMax) * heightPlotArea);
      g.drawLine(ix0, iy0, ix1, iy1);
      ix0 = ix1;
      iy0 = iy1;
    }
    g.setStroke(savedStroke);
    g.setColor(Color.BLACK);
  }
 /**
  * Draw the decoration. If the curve is null when this is called, then curve will be set to the
  * exhibit displayed in the View, which should be of type PlaneCurveParameteric, if this
  * decoration is being used correctly.
  */
 public void doDraw(Graphics2D g, View view, Transform limits) {
   if (curve == null && view != null) {
     Exhibit c = view.getExhibit();
     if (c instanceof PlaneCurveParametric) // It better be!
     curve = (PlaneCurveParametric) c;
     else return;
   }
   if (Double.isNaN(t)) return;
   double x = curve.xValue(t);
   if (Double.isNaN(x) || Double.isInfinite(x)) return;
   double y = curve.yValue(t);
   if (Double.isNaN(y) || Double.isInfinite(y)) return;
   double dx = curve.xDerivativeValue(t);
   if (Double.isNaN(dx) || Double.isInfinite(dx)) return;
   double dy = curve.yDerivativeValue(t);
   if (Double.isNaN(dy) || Double.isInfinite(dy)) return;
   double length = Math.sqrt(dx * dx + dy * dy);
   if (length == 0) return;
   dx = dx / length * 40 * limits.getPixelWidth();
   dy = dy / length * 40 * limits.getPixelHeight();
   Color saveColor = g.getColor();
   Stroke saveStroke = g.getStroke();
   g.setStroke(new BasicStroke(2 * limits.getDefaultStrokeSize()));
   g.setColor(Color.red);
   g.draw(new Line2D.Double(x, y, x + dx, y + dy));
   g.setColor(Color.blue);
   g.draw(new Line2D.Double(x, y, x - dy, y + dx));
   g.setColor(saveColor);
   g.setStroke(saveStroke);
 }
Example #16
0
  public void draw(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;

    int hGap = 0;
    int y1 = this.y1;

    if (hPosition) {
      hGap = hGap + grpage.hPosition;
      gapH = hGap;
    }

    y1 = y1 + hGap;

    Color oldC = g2d.getColor();
    Stroke oldStroke = g2d.getStroke();

    g2d.setColor(Color.BLUE);
    Composite compositeOld = g2d.getComposite();

    if (selected) {
      g2d.setStroke(new BasicStroke(2.0f));
    }
    g2d.drawRect(0, y1, width, height);

    g2d.setComposite(composite);
    g2d.setPaint(Color.BLUE);
    g2d.fill(new Rectangle(0, y1, width, height));

    g2d.setComposite(compositeOld);
    g2d.setColor(oldC);
    g2d.setStroke(oldStroke);

    yRelative = y1;
    grpage.hPosition = y1 + height;
  }
Example #17
0
 /** 自定义虚线的绘制方法 */
 protected void drawLine(Graphics2D g2d, int x1, int y1, int x2, int y2) {
   Stroke stroke = g2d.getStroke();
   g2d.setStroke(
       new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, dashparams, 0));
   super.drawLine(g2d, x1, y1, x2, y2);
   g2d.setStroke(stroke);
 }
Example #18
0
  @Override
  protected void fillTitleBar(Graphics2D g2) {
    Paint oldPaint = g2.getPaint();
    Stroke oldStroke = g2.getStroke();

    g2.setColor(new Color(241, 241, 241));
    g2.setStroke(new BasicStroke(1));
    g2.drawLine(0, 0, getWidth(), 0);

    LinearGradientPaint p =
        new LinearGradientPaint(
            1f,
            1f,
            1f,
            getHeight() - 1,
            new float[] {0.0f, 0.499f, 0.5f, 1.0f},
            new Color[] {
              new Color(230, 230, 230),
              new Color(202, 202, 202),
              new Color(202, 202, 202),
              new Color(178, 178, 178)
            });
    g2.setPaint(p);
    g2.fillRect(0, 0, getWidth(), this.getHeight() - 1);

    g2.setPaint(oldPaint);
    g2.setColor(new Color(104, 104, 104));
    g2.setStroke(new BasicStroke(1));
    g2.drawLine(getX(), getHeight() - 1, getWidth(), getHeight() - 1);

    g2.setStroke(oldStroke);
  }
Example #19
0
  // From: http://forum.java.sun.com/thread.jspa?threadID=378460&tstart=135
  void drawArrow(
      Graphics2D g2d,
      int xCenter,
      int yCenter,
      int x,
      int y,
      float stroke,
      BasicStroke drawStroke) {
    double aDir = Math.atan2(xCenter - x, yCenter - y);
    // Line can be dashed.
    g2d.setStroke(drawStroke);
    g2d.drawLine(x, y, xCenter, yCenter);
    // make the arrow head solid even if dash pattern has been specified
    g2d.setStroke(lineStroke);
    Polygon tmpPoly = new Polygon();
    int i1 = 12 + (int) (stroke * 2);
    // make the arrow head the same size regardless of the length length
    int i2 = 6 + (int) stroke;
    tmpPoly.addPoint(x, y);
    tmpPoly.addPoint(x + xCor(i1, aDir + .5), y + yCor(i1, aDir + .5));
    tmpPoly.addPoint(x + xCor(i2, aDir), y + yCor(i2, aDir));
    tmpPoly.addPoint(x + xCor(i1, aDir - .5), y + yCor(i1, aDir - .5));
    tmpPoly.addPoint(x, y); // arrow tip
    g2d.drawPolygon(tmpPoly);

    // Remove this line to leave arrow head unpainted:
    g2d.fillPolygon(tmpPoly);
  }
  /* (non-Javadoc)
   * @see maptool.model.drawing.Drawable#draw(java.awt.Graphics2D, maptool.model.drawing.Pen)
   */
  public void draw(Graphics2D g, Pen pen, int translateX, int translateY) {
    if (pen == null) {
      pen = Pen.DEFAULT;
    }

    Stroke oldStroke = g.getStroke();
    g.setStroke(new BasicStroke(pen.getThickness(), BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));

    Composite oldComposite = g.getComposite();
    if (pen.isEraser()) {
      g.setComposite(AlphaComposite.Clear);
    }

    if (pen.getBackgroundMode() == Pen.MODE_SOLID) {
      Color bgColor = new Color(pen.getBackgroundColor());
      g.setColor(bgColor);
      drawBackground(g, translateX, translateY);
    }

    if (pen.getForegroundMode() == Pen.MODE_SOLID) {
      Color color = new Color(pen.getColor());
      g.setColor(color);
      draw(g, translateX, translateY);
    }

    g.setComposite(oldComposite);
    g.setStroke(oldStroke);
  }
  public void draw(Graphics g) {
    // 19-2-2008 Removed showing the horizontal and vertical segment constraints
    if (true) return;
    if ((m_seg.getM_parentStk().getM_type() == Stroke.TYPE_NORMAL) && (m_seg.isEnabled())) {
      Graphics2D g2d = (Graphics2D) g;
      // set the color of the graphics to the color of the segment
      Color prevColor = g.getColor();
      g2d.setColor(getColor());

      // create a dashed line for radii lines
      BasicStroke prevStroke = (BasicStroke) g2d.getStroke();
      g2d.setColor(GVariables.DRAWING_ASSIST_COLOR);
      g2d.setStroke(
          new BasicStroke(
              prevStroke.getLineWidth(),
              prevStroke.getEndCap(),
              prevStroke.getLineJoin(),
              prevStroke.getMiterLimit(),
              new float[] {4, 4, 8, 4},
              prevStroke.getDashPhase()));
      g2d.draw(marker_line);
      g2d.setStroke(prevStroke);
      g2d.draw(marker_rect);

      // reset the graphics color back
      g2d.setColor(prevColor);
    }
  }
  @Override
  public void paintComponent(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    super.paintComponent(g);

    /*TODO solution pas terrible pour les GLiens qui servent un peu ˆ rienÉ*/
    for (int i = 0; i < gLiens.size(); i++) {
      g2d.setStroke(new BasicStroke(2));
      g2d.drawLine(
          (int) gLiens.get(i).getA().getCentreX(),
          (int) gLiens.get(i).getA().getCentreY(),
          (int) gLiens.get(i).getB().getCentreX(),
          (int) gLiens.get(i).getB().getCentreY());
    }

    for (int i = 0; i < gLiensConditionnels.size(); i++) {
      g2d.setColor(Color.RED);
      g2d.setStroke(new BasicStroke(2));
      g2d.drawLine(
          (int) gLiensConditionnels.get(i).getA().getCentreX() - 2,
          (int) gLiensConditionnels.get(i).getA().getCentreY() - 2,
          (int) gLiensConditionnels.get(i).getB().getCentreX() - 2,
          (int) gLiensConditionnels.get(i).getB().getCentreY() - 2);
    }

    for (int i = 0; i < this.gLinksTrigger.size(); i++) {
      g2d.setColor(Color.ORANGE);
      g2d.setStroke(new BasicStroke(3));
      g2d.drawLine(
          (int) gLinksTrigger.get(i).getA().getCentreX() - 2,
          (int) gLinksTrigger.get(i).getA().getCentreY() - 2,
          (int) gLinksTrigger.get(i).getB().getCentreX() - 2,
          (int) gLinksTrigger.get(i).getB().getCentreY() - 2);
    }
  }
  protected void drawTask(String name, int x, int y, int width, int height, boolean thickBorder) {
    Paint originalPaint = g.getPaint();

    // Create a new gradient paint for every task box, gradient depends on x and y and is not
    // relative
    g.setPaint(new GradientPaint(x + 50, y, Color.white, x + 50, y + 50, TASK_BOX_COLOR));

    // shape
    RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
    g.fill(rect);
    g.setPaint(originalPaint);

    if (thickBorder) {
      Stroke originalStroke = g.getStroke();
      g.setStroke(THICK_TASK_BORDER_STROKE);
      g.draw(rect);
      g.setStroke(originalStroke);
    } else {
      g.draw(rect);
    }

    // text
    if (name != null) {
      drawMultilineText(name, x, y, width, height);
    }
  }
  @Override
  protected void paint(DecorationLayer layer, Graphics2D g, RadComponent container) {
    if (!layer.showSelection() || container.getClientProperty(SnapPointFeedbackHost.KEY) != null) {
      return;
    }

    Stroke stroke = g.getStroke();
    g.setStroke(SnapPointFeedbackHost.STROKE);
    g.setColor(SnapPointFeedbackHost.COLOR);

    Rectangle bounds = container.getBounds(layer);
    Map<RadComponent, RelativeInfo> relativeInfos = container.getClientProperty(RelativeInfo.KEY);
    List<RadComponent> selection = layer.getArea().getSelection();

    for (RadComponent component : selection) {
      RelativeInfo info = relativeInfos.get(component);
      if (info != null) {
        paintOutRelative(layer, g, component, info);
        paintContainerRelative(g, bounds, info);
      }
    }

    g.setStroke(stroke);
    g.setColor(JBColor.ORANGE);

    for (RadComponent component : selection) {
      RelativeInfo info = relativeInfos.get(component);
      if (info != null) {
        paintContainerMarginRelative(layer, g, bounds, (RadViewComponent) component, info);
      }
    }
  }
  public void drawMultiInstanceMarker(boolean sequential, int x, int y, int width, int height) {
    int rectangleWidth = MARKER_WIDTH;
    int rectangleHeight = MARKER_WIDTH;
    int lineX = x + (width - rectangleWidth) / 2;
    int lineY = y + height - rectangleHeight - 3;

    Stroke orginalStroke = g.getStroke();
    g.setStroke(MULTI_INSTANCE_STROKE);

    if (sequential) {
      g.draw(new Line2D.Double(lineX, lineY, lineX + rectangleWidth, lineY));
      g.draw(
          new Line2D.Double(
              lineX,
              lineY + rectangleHeight / 2,
              lineX + rectangleWidth,
              lineY + rectangleHeight / 2));
      g.draw(
          new Line2D.Double(
              lineX, lineY + rectangleHeight, lineX + rectangleWidth, lineY + rectangleHeight));
    } else {
      g.draw(new Line2D.Double(lineX, lineY, lineX, lineY + rectangleHeight));
      g.draw(
          new Line2D.Double(
              lineX + rectangleWidth / 2,
              lineY,
              lineX + rectangleWidth / 2,
              lineY + rectangleHeight));
      g.draw(
          new Line2D.Double(
              lineX + rectangleWidth, lineY, lineX + rectangleWidth, lineY + rectangleHeight));
    }

    g.setStroke(orginalStroke);
  }
  /**
   * Draws the graphic item within the specified area.
   *
   * @param g2 the graphics device.
   * @param area the area.
   */
  public void draw(Graphics2D g2, Rectangle2D area) {
    area = (Rectangle2D) area.clone();
    area = trimMargin(area);
    drawBorder(g2, area);
    area = trimBorder(area);
    area = trimPadding(area);

    if (this.lineVisible) {
      Point2D location = RectangleAnchor.coordinates(area, this.shapeLocation);
      Shape aLine =
          ShapeUtilities.createTranslatedShape(
              getLine(), this.shapeAnchor, location.getX(), location.getY());
      g2.setPaint(this.linePaint);
      g2.setStroke(this.lineStroke);
      g2.draw(aLine);
    }

    if (this.shapeVisible) {
      Point2D location = RectangleAnchor.coordinates(area, this.shapeLocation);

      Shape s =
          ShapeUtilities.createTranslatedShape(
              this.shape, this.shapeAnchor, location.getX(), location.getY());
      if (this.shapeFilled) {
        g2.setPaint(this.fillPaint);
        g2.fill(s);
      }
      if (this.shapeOutlineVisible) {
        g2.setPaint(this.outlinePaint);
        g2.setStroke(this.outlineStroke);
        g2.draw(s);
      }
    }
  }
  private void drawSelection(Graphics2D g2d) {
    if (srcx != destx || srcy != desty) {
      int x1 = (srcx < destx) ? srcx : destx;
      int y1 = (srcy < desty) ? srcy : desty;
      int x2 = (srcx > destx) ? srcx : destx;
      int y2 = (srcy > desty) ? srcy : desty;

      rectSelection.x = x1;
      rectSelection.y = y1;
      rectSelection.width = (x2 - x1) + 1;
      rectSelection.height = (y2 - y1) + 1;
      if (rectSelection.width > 0 && rectSelection.height > 0) {
        g2d.drawImage(scr_img.getSubimage(x1, y1, x2 - x1 + 1, y2 - y1 + 1), null, x1, y1);
      }

      g2d.setColor(selFrameColor);
      g2d.setStroke(bs);
      g2d.draw(rectSelection);
      int cx = (x1 + x2) / 2;
      int cy = (y1 + y2) / 2;
      g2d.setColor(selCrossColor);
      g2d.setStroke(_StrokeCross);
      g2d.drawLine(cx, y1, cx, y2);
      g2d.drawLine(x1, cy, x2, cy);

      if (Screen.getNumberScreens() > 1) {
        drawScreenFrame(g2d, srcScreenId);
      }
    }
  }
Example #28
0
 /** Draws the edge structure of the tree */
 public void drawEdges(Graphics2D gg) {
   gg.setPaint(Color.black);
   Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
   // For each vertex...
   while (nodeList.hasMoreElements()) {
     // Get its edge list...
     TreeVertex vertex = (TreeVertex) nodeList.nextElement();
     Enumeration edges = vertex.getEdgeList().elements();
     // For each edge in the list...
     while (edges.hasMoreElements()) {
       TreeEdge edge = (TreeEdge) edges.nextElement();
       // If we have several vertices on layer 0, only draw
       // edges for layers below that
       if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) {
         // If the edge has been selected with the mouse,
         // use a thick line
         if (edge.isSelected()) {
           gg.setStroke(selectStroke);
         }
         gg.draw(edge.getShape(this));
         // If we used a thick line, reset the stroke to normal
         // line for next edge.
         if (edge.isSelected()) {
           gg.setStroke(solidStroke);
         }
         TreeVertex edgeSource = edge.getDestVertex();
       }
     }
   }
 }
Example #29
0
  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2d = (Graphics2D) g;
    g2d.setBackground(Color.LIGHT_GRAY);
    g2d.clearRect(0, 0, getParent().getWidth(), getParent().getHeight());

    // Red line
    g2d.setPaint(Color.RED);
    // 5 visible, 5 invisible
    final float dash[] = {5, 5};
    // 10 thick, end lines with no cap,
    // any joins make round, miter limit,
    // dash array, dash phase
    final BasicStroke dashed =
        new BasicStroke(10, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 0, dash, 0);

    g2d.setStroke(dashed);
    g2d.drawLine(100, 10, 10, 110);

    // White line
    g2d.setPaint(Color.WHITE);
    g2d.setStroke(new BasicStroke(10.0f));
    g2d.draw(new Line2D.Float(150, 10, 10, 160));

    // Blue line
    g2d.setPaint(Color.BLUE);
    Stroke solidStroke = new BasicStroke(10, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
    g2d.setStroke(solidStroke);
    g2d.draw(new Line2D.Float(new Point2D.Float(200, 10), new Point2D.Double(10, 210)));
  }
Example #30
0
  @Override
  public void draw(Graphics2D g2d, Surface s) {

    g2d.setPaint(getColor());
    g2d.fill(getSurface());

    if (getHover() && !selected) {
      Stroke outl = new BasicStroke(2f);
      g2d.setStroke(outl);
      if (getColor() != Color.red) g2d.setPaint(Color.red);
      else g2d.setPaint(Color.BLACK);
      g2d.drawPolygon(getSurface());
    } else if (selected) {
      float[] dash = {4f, 0f, 2f};
      BasicStroke outl =
          new BasicStroke(
              2f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash, getFramesAlive() * .2f);
      g2d.setStroke(outl);

      if (ownedby.equals(Player.NONE)) {
        g2d.setPaint(Color.black);
      } else if (ownedby.equals(Player.COMPUTER)) {
        g2d.setPaint(Color.RED);
      } else if (ownedby.equals(Player.PLAYER)) {
        g2d.setPaint(Color.BLUE);
      }

      g2d.drawPolygon(getSurface());
    }

    g2d.setPaint(Color.BLUE.brighter());
    for (Territory t : neighbors) {
      double distance;
      if (CalculateDistance(this.capital.x, this.capital.y, t.GetCapital().x, t.GetCapital().y)
          < 800) g2d.drawLine(this.capital.x, this.capital.y, t.GetCapital().x, t.GetCapital().y);
      else {
        if (CalculateDistance(this.capital.x, this.capital.y, 0, 0) < 500) {
          g2d.drawLine(this.capital.x, this.capital.y, 0, 70);
        } else if (CalculateDistance(this.capital.x, this.capital.y, 0, 0) > 500) {
          g2d.drawLine(this.capital.x, this.capital.y, 1280, 70);
        }
      }
    }

    if (ownedby.equals(Player.NONE)) {
      g2d.setPaint(Color.black);
    } else if (ownedby.equals(Player.COMPUTER)) {
      g2d.setPaint(Color.RED);
    } else if (ownedby.equals(Player.PLAYER)) {
      g2d.setPaint(Color.BLUE);
    }

    g2d.setFont(new Font("TimesRoman", Font.PLAIN, 18));
    g2d.setStroke(new BasicStroke(1f));
    g2d.fillOval(capital.x - 10, capital.y - 10, 20, 20);
    g2d.setPaint(Color.BLACK);
    g2d.drawOval(capital.x - 10, capital.y - 10, 20, 20);
    g2d.setPaint(Color.WHITE);
    g2d.drawString("" + armies, capital.x - 5, capital.y + 5);
  }