/**
   * Constructs a <code>LinearGradientPaint</code>.
   *
   * @param start the gradient axis start <code>Point</code> in user space
   * @param end the gradient axis end <code>Point</code> in user space
   * @param fractions numbers ranging from 0.0 to 1.0 specifying the distribution of colors along
   *     the gradient
   * @param colors array of colors corresponding to each fractional value
   * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
   * @param colorSpace which colorspace to use for interpolation, either SRGB or LINEAR_RGB
   * @param gradientTransform transform to apply to the gradient
   * @throws NullPointerException if one of the points is null, or gradientTransform is null
   * @throws IllegalArgumentException if start and end points are the same points, or if
   *     fractions.length != colors.length, or if colors is less than 2 in size.
   */
  public LinearGradientPaint(
      Point2D start,
      Point2D end,
      float[] fractions,
      Color[] colors,
      CycleMethodEnum cycleMethod,
      ColorSpaceEnum colorSpace,
      AffineTransform gradientTransform) {
    super(fractions, colors, cycleMethod, colorSpace, gradientTransform);

    //
    // Check input parameters
    //
    if (start == null || end == null) {
      throw new NullPointerException("Start and end points must be" + "non-null");
    }

    if (start.equals(end)) {
      throw new IllegalArgumentException("Start point cannot equal" + "endpoint");
    }

    // copy the points...
    this.start = (Point2D) start.clone();

    this.end = (Point2D) end.clone();
  }
Esempio n. 2
0
 /** JDGradientPaintの複製を作成します. */
 public JDGradientPaint clone() {
   return new JDGradientPaint(
       (Point2D) p1.clone(),
       (Point2D) p2.clone(),
       c1,
       c2,
       controlPoints.clone(),
       colors.clone(),
       gType);
 }
 /** Copies the control points to the edit point list. */
 private void copyConnectionPointsToEditPoints() {
   editpoints.clear();
   editedOffset = 0;
   for (Point2D point : getConnection().getPoints()) {
     editpoints.add((Point2D) point.clone());
   }
 }
 public Frame(Point2D point, Vector2D vec1, Vector2D vec2)
     throws NoninvertibleTransformException {
   toStd_ =
       new AffineTransform(
           vec1.getX(), vec1.getY(), vec2.getX(), vec2.getY(), point.getX(), point.getY());
   fromStd_ = toStd_.createInverse();
   origin_ = (Point2D) point.clone();
   xAxis_ = new Vector2D(vec1);
   yAxis_ = new Vector2D(vec2);
 }
  /**
   * Computes the destination point corresponding to the supplied point.
   *
   * @param sourcePt the position in source image coordinates to map to destination image
   *     coordinates.
   * @return a <code>Point2D</code> of the same class as <code>sourcePt</code>.
   * @throws IllegalArgumentException if <code>sourcePt</code> is <code>null</code>.
   * @since JAI 1.1.2
   */
  public Point2D mapSourcePoint(Point2D sourcePt) {
    if (sourcePt == null) {
      throw new IllegalArgumentException(JaiI18N.getString("Generic0"));
    }

    Point2D pt = (Point2D) sourcePt.clone();

    pt.setLocation(sourcePt.getX() / 4.0, sourcePt.getY() / 4.0);

    return pt;
  }
  /**
   * Computes the source point corresponding to the supplied point.
   *
   * @param destPt the position in destination image coordinates to map to source image coordinates.
   * @return a <code>Point2D</code> of the same class as <code>destPt</code>.
   * @throws IllegalArgumentException if <code>destPt</code> is <code>null</code>.
   * @since JAI 1.1.2
   */
  public Point2D mapDestPoint(Point2D destPt) {
    if (destPt == null) {
      throw new IllegalArgumentException(JaiI18N.getString("Generic0"));
    }

    Point2D pt = (Point2D) destPt.clone();

    pt.setLocation(destPt.getX() * 4.0, destPt.getY() * 4.0);

    return pt;
  }
Esempio n. 7
0
 public Point2D evaluate(Point2D v0, Point2D v1, float fraction) {
   if (value == null) {
     // TODO: Note that future calls to this Evaluator may
     // use a different subclass of Point2D, so the precision of the
     // result may vary because we are caching a clone of
     // the first instance we received
     value = (Point2D) v0.clone();
   }
   double x = v0.getX() + ((v1.getX() - v0.getX()) * fraction);
   double y = v0.getY() + ((v1.getY() - v0.getY()) * fraction);
   value.setLocation(x, y);
   return value;
 }
Esempio n. 8
0
  /** {@inheritDoc} */
  public void processInput() {
    if (nextInput == null) {
      return;
    }

    final PInputEvent e = new PInputEvent(this, nextInput);

    Point2D newCurrentCanvasPosition = null;
    Point2D newLastCanvasPosition = null;

    if (e.isMouseEvent()) {
      if (e.isMouseEnteredOrMouseExited()) {
        final PPickPath aPickPath =
            nextInputSource.pick(
                ((MouseEvent) nextInput).getX(), ((MouseEvent) nextInput).getY(), 1);
        setMouseOver(aPickPath);
        previousMouseOver = aPickPath;
        newCurrentCanvasPosition = (Point2D) currentCanvasPosition.clone();
        newLastCanvasPosition = (Point2D) lastCanvasPosition.clone();
      } else {
        lastCanvasPosition.setLocation(currentCanvasPosition);
        currentCanvasPosition.setLocation(
            ((MouseEvent) nextInput).getX(), ((MouseEvent) nextInput).getY());
        final PPickPath aPickPath =
            nextInputSource.pick(currentCanvasPosition.getX(), currentCanvasPosition.getY(), 1);
        setMouseOver(aPickPath);
      }
    }

    nextInput = null;
    nextInputSource = null;

    processEvent(e, nextType);

    if (newCurrentCanvasPosition != null && newLastCanvasPosition != null) {
      currentCanvasPosition.setLocation(newCurrentCanvasPosition);
      lastCanvasPosition.setLocation(newLastCanvasPosition);
    }
  }
 public Frame(Point2D origin, Point2D ptX, Point2D ptY) throws NoninvertibleTransformException {
   toStd_ =
       new AffineTransform(
           ptX.getX() - origin.getX(),
           ptX.getY() - origin.getY(),
           ptY.getX() - origin.getX(),
           ptY.getY() - origin.getY(),
           origin.getX(),
           origin.getY());
   fromStd_ = toStd_.createInverse();
   origin_ = (Point2D) origin.clone();
   xAxis_ = new Vector2D(origin, ptX).normalized();
   yAxis_ = new Vector2D(origin, ptY).normalized();
 }
 private Shape createArrowHead(Graphics g) {
   if (line == null) return null;
   double size = getLineHeadSize();
   Point2D lineStart = line.getP1();
   Point2D lineEnd = line.getP2();
   double d = Math.max(1.0, lineEnd.distance(lineStart));
   double ax = -(size * (lineEnd.getX() - lineStart.getX()) / d);
   double ay = -(size * (lineEnd.getY() - lineStart.getY()) / d);
   Polygon poly = new Polygon();
   poly.addPoint((int) lineEnd.getX(), (int) lineEnd.getY());
   poly.addPoint((int) (lineEnd.getX() + ax + ay / 2), (int) (lineEnd.getY() + ay - ax / 2));
   Point2D last = (Point2D) lineEnd.clone();
   lineEnd.setLocation(lineEnd.getX() + ax, lineEnd.getY() + ay);
   poly.addPoint((int) (last.getX() + ax - ay / 2), (int) (last.getY() + ay + ax / 2));
   return poly;
 }
Esempio n. 11
0
 /** Returns the reference point of this marker. */
 public Point2D getRef() {
   return (Point2D) ref.clone();
 }
Esempio n. 12
0
 public Point2D getPoint() {
   return (Point2D) point.clone();
 }
 /** {@inheritDoc} */
 public Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
   return (Point2D) srcPt.clone();
 }
Esempio n. 14
0
 private void movePoint(int ptIndex, Point2D newPt, boolean adjustBounds) {
   points.set(ptIndex, (Point2D) newPt.clone());
   // TODO: implement adjustBounds == true
 }
Esempio n. 15
0
  private void calulatePoints() {
    Point2D sourcePos = null;
    Point2D destinationPos = null;

    if (link.getNode1() != link.getNode2()) {
      /* Ako veza spaja razlicite cvorove. */
      sourcePos = link.getNode1().getPosition();
      destinationPos = link.getNode2().getPosition();
    } else {
      /* Ako je u pitanju rekurzivna veza. */
      double x = link.getNode1().getPosition().getX();
      double y = link.getNode1().getPosition().getY();
      sourcePos = new Point2D.Double(x - NodePainter.NODE_RADIOUS, y);
      destinationPos = new Point2D.Double(x, y - NodePainter.NODE_RADIOUS);
    }

    /* Rastojanje izmedju tacaka krajeva krive. */
    double distance =
        Math.sqrt(
            Math.pow(sourcePos.getX() - destinationPos.getX(), 2)
                + Math.pow(sourcePos.getY() - destinationPos.getY(), 2));

    /*
     * Pocetna tacka. Podesava se tako da pocinje na ivici kruga koji
     * predstavlja cvor.
     */
    if (link.getNode1() != link.getNode2()) {
      begin =
          new Point2D.Double(
              sourcePos.getX()
                  - NodePainter.NODE_RADIOUS
                      * (sourcePos.getX() - destinationPos.getX())
                      / distance,
              sourcePos.getY()
                  - NodePainter.NODE_RADIOUS
                      * (sourcePos.getY() - destinationPos.getY())
                      / distance);

      /* Koordinate krajnje tacke veze. */
      end =
          new Point2D.Double(
              destinationPos.getX()
                  - NodePainter.NODE_RADIOUS
                      * (destinationPos.getX() - sourcePos.getX())
                      / distance,
              destinationPos.getY()
                  - NodePainter.NODE_RADIOUS
                      * (destinationPos.getY() - sourcePos.getY())
                      / distance);
    } else {
      begin = (Point2D) sourcePos.clone();
      end = (Point2D) destinationPos.clone();
    }

    /*
     * Znak faktora. Omogucava iscrtavanje veze sa obe strane duzi koja
     * spaja cvorove.
     */
    int curveFactor =
        graphView.getPaintedLinkCounter().getNumberOfLinks(link.getNode1(), link.getNode2());

    int factorSign = 1;

    if (link.getNode1() != link.getNode2()) {
      /* Ako veza spaja razlicite cvorove. */
      curveFactor++;
      factorSign = (curveFactor % 2 == 0 ? 1 : -1);
    } else {
      /* Ako je u pitanju rekurzivna veza. */
      curveFactor +=
          4
              + graphView.getPaintedLinkCounter().getNumberOfLinks(link.getNode1(), link.getNode2())
                  / 1;
    }

    /* Izracunavanje konacnog faktora zakrivljenosti. */
    double factor = factorSign * (curveFactor / 2) * 20;

    /* Koordinate tacke bezierove krive. */
    bezierCurveCoords =
        calculatePoint(
            new Point2D.Double(begin.getX(), begin.getY()),
            new Point2D.Double(end.getX(), end.getY()),
            factor);

    /* Koordinate kruga na sredini veze. */
    middleCircleCoords =
        calculatePoint(
            new Point2D.Double(begin.getX(), begin.getY()),
            new Point2D.Double(end.getX(), end.getY()),
            factor * 3.75 / 5);

    double size4 = graphView.sizeToUserSpace(4);
    double size8 = graphView.sizeToUserSpace(8);

    shape =
        new Ellipse2D.Double(
            middleCircleCoords.getX() - size4, middleCircleCoords.getY() - size4, size8, size8);

    /* Trougao. */
    triangle = new Polygon();
    triangle.addPoint(
        (int) Math.round((-size4 * Math.sqrt(3) / 2 + 0.1)), (int) Math.round((size4 / 2 + 0.1)));
    triangle.addPoint(0, (int) -size4);
    triangle.addPoint(
        (int) Math.round((size4 * Math.sqrt(3) / 2 + 0.1)), (int) Math.round(size4 / 2 + 0.1));
  }
Esempio n. 16
0
  /**
   * Return corresponding destination point for source point. Because this is not a geometric
   * operation, it simply returns a copy of the source.
   *
   * @param src The source point.
   * @param dst The destination point.
   * @return dst The destination point.
   * @see java.awt.image.RasterOp#getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
   */
  public final Point2D getPoint2D(Point2D src, Point2D dst) {
    if (dst == null) return (Point2D) src.clone();

    dst.setLocation(src);
    return dst;
  }
Esempio n. 17
0
 /**
  * gets the difference of two points
  *
  * @param tar
  * @param src
  * @return difference
  */
 public static Point2D diff(Point2D tar, Point2D src) {
   Point2D result = (Point2D) tar.clone();
   result.setLocation(result.getX() - src.getX(), result.getY() - src.getY());
   return result;
 }