How to use

AttributeKeys

in

org.jhotdraw.draw

  /**
   * Returns the distance, that a Rectangle needs to grow (or shrink) to
   * make hit detections on a shape as specified by the FILL_UNDER_STROKE and STROKE_POSITION
   * attributes of a figure.
   * The value returned is the number of units that need to be grown (or shrunk)
   * perpendicular to a stroke on an outline of the shape.
   */
  public static double getPerpendicularHitGrowth(Figure f) {
    double grow;
    if (f.get(STROKE_COLOR) == null) {
      grow = getPerpendicularFillGrowth(f);
    } else {
      double strokeWidth = AttributeKeys.getStrokeTotalWidth(f);
      grow = getPerpendicularDrawGrowth(f) + strokeWidth / 2d;
    }
    return grow;
  }
}

@Override
public Rectangle2D.Double getDrawingArea() {
  Rectangle2D.Double r = (Rectangle2D.Double) roundrect.getBounds2D();
  double grow = AttributeKeys.getPerpendicularHitGrowth(this) + 1;
  Geom.grow(r, grow, grow);
  return r;
}

@Override
public Font getFont() {
  return AttributeKeys.getFont(this);
}

@Override
protected void drawFill(Graphics2D g) {
  Shape triangle = getBezierPath();
  double grow = AttributeKeys.getPerpendicularFillGrowth(this);
  if (grow != 0d) {
    GrowStroke gs = new GrowStroke((float) grow,
        (float) (AttributeKeys.getStrokeTotalWidth(this) *
        get(STROKE_MITER_LIMIT))
        );
    triangle = gs.createStrokedShape(triangle);
  }
  
  g.fill(triangle);
}

@Override
protected void drawStroke(Graphics2D g) {
  Shape triangle = getBezierPath();
  
  double grow = AttributeKeys.getPerpendicularDrawGrowth(this);
  if (grow != 0d) {
    GrowStroke gs = new GrowStroke((float) grow,
        (float) (AttributeKeys.getStrokeTotalWidth(this) *
        get(STROKE_MITER_LIMIT))
        );
    triangle = gs.createStrokedShape(triangle);
  }
  
  g.draw(triangle);
}
@Override

public Point2D.Double chop(Point2D.Double p) {
  Shape triangle = getBezierPath();
  
  double grow = AttributeKeys.getPerpendicularHitGrowth(this);
  if (grow != 0d) {
    GrowStroke gs = new GrowStroke((float) grow,
        (float) (AttributeKeys.getStrokeTotalWidth(this) *
        get(STROKE_MITER_LIMIT))
        );
    triangle =gs.createStrokedShape(triangle);
  }
  return Geom.chop(triangle, p);
}
/**

@Override
protected void drawFill(Graphics2D g) {
  Ellipse2D.Double r = (Ellipse2D.Double) ellipse.clone();
  double grow = AttributeKeys.getPerpendicularFillGrowth(this);
  r.x -= grow;
  r.y -= grow;
  r.width += grow * 2;
  r.height += grow * 2;
  if (r.width > 0 && r.height > 0) {
    g.fill(r);
  }
}

@Override
protected void drawStroke(Graphics2D g) {
  Ellipse2D.Double r = (Ellipse2D.Double) ellipse.clone();
  double grow = AttributeKeys.getPerpendicularDrawGrowth(this);
  r.x -= grow;
  r.y -= grow;
  r.width += grow * 2;
  r.height += grow * 2;
  if (r.width > 0 && r.height > 0) {
    g.draw(r);
  }
}

@Override
public boolean contains(Point2D.Double p) {
  return Geom.lineContainsPoint(
      line.x1, line.y1,
      line.x2, line.y2,
      p.x, p.y,
      AttributeKeys.getStrokeTotalWidth(this));
}

public Stroke getStroke() {
  return AttributeKeys.getStroke(this);
}

float miterLimit = (float) getStrokeTotalMiterLimit(f);
double dashFactor = f.get(IS_STROKE_DASH_FACTOR) ? strokeWidth : 1d;
switch (f.get(STROKE_TYPE)) {

@Nullable public static Font getFont(Figure f) {
  Font prototype = f.get(FONT_FACE);
  if (prototype == null) {
    return null;
  }
  if (getFontStyle(f) != Font.PLAIN) {
    return prototype.deriveFont(getFontStyle(f), f.get(FONT_SIZE).floatValue());
  } else {
    return prototype.deriveFont(f.get(FONT_SIZE).floatValue());
  }
}

/**
 * Checks if a Point2D.Double is inside the figure.
 */
@Override
public boolean contains(Point2D.Double p) {
  Shape triangle = getBezierPath();
  
  double grow = AttributeKeys.getPerpendicularHitGrowth(this);
  if (grow != 0d) {
    GrowStroke gs = new GrowStroke((float) grow,
        (float) (AttributeKeys.getStrokeTotalWidth(this) *
        get(STROKE_MITER_LIMIT))
        );
    triangle =gs.createStrokedShape(triangle);
  }
  return triangle.contains(p);
}
@Override

@Override
protected void drawFill(Graphics2D g) {
  RoundRectangle2D.Double r = (RoundRectangle2D.Double) roundrect.clone();
  double grow = AttributeKeys.getPerpendicularFillGrowth(this);
  r.x -= grow;
  r.y -= grow;
  r.width += grow * 2;
  r.height += grow * 2;
  r.arcwidth += grow * 2;
  r.archeight += grow * 2;
  if (r.width > 0 && r.height > 0) {
    g.fill(r);
  }
}

@Override
protected void drawStroke(Graphics2D g) {
  RoundRectangle2D.Double r = (RoundRectangle2D.Double) roundrect.clone();
  double grow = AttributeKeys.getPerpendicularDrawGrowth(this);
  r.x -= grow;
  r.y -= grow;
  r.width += grow * 2;
  r.height += grow * 2;
  r.arcwidth += grow * 2;
  r.archeight += grow * 2;
  if (r.width > 0 && r.height > 0) {
    g.draw(r);
  }
}
// SHAPE AND BOUNDS

@Override
protected void drawFill(Graphics2D g) {
  if (isClosed() || get(UNCLOSED_PATH_FILLED)) {
    double grow = AttributeKeys.getPerpendicularFillGrowth(this);
    if (grow == 0d) {
      g.fill(path);
    } else {
      GrowStroke gs = new GrowStroke(grow,
          AttributeKeys.getStrokeTotalWidth(this)
          * get(STROKE_MITER_LIMIT));
      g.fill(gs.createStrokedShape(path));
    }
  }
}

@Override
protected void drawStroke(Graphics2D g) {
  if (isClosed()) {
    double grow = AttributeKeys.getPerpendicularDrawGrowth(this);
    if (grow == 0d) {
      g.draw(path);
    } else {
      GrowStroke gs = new GrowStroke(grow,
          AttributeKeys.getStrokeTotalWidth(this)
          * get(STROKE_MITER_LIMIT));
      g.draw(gs.createStrokedShape(path));
    }
  } else {
    g.draw(getCappedPath());
  }
  drawCaps(g);
}

/**
 * Returns the distance, that a Rectangle needs to grow (or shrink) to
 * draw (aka stroke) its shape as specified by the FILL_UNDER_STROKE and 
 * STROKE_POSITION attributes of a figure.
 * The value returned is the number of units that need to be grown (or shrunk)
 * perpendicular to a stroke on an outline of the shape.
 */
public static double getPerpendicularDrawGrowth(Figure f) {
  double grow;
  double strokeWidth = AttributeKeys.getStrokeTotalWidth(f);
  switch (f.get(STROKE_PLACEMENT)) {
    case INSIDE:
      grow = strokeWidth / -2d;
      break;
    case OUTSIDE:
      grow = strokeWidth / 2d;
      break;
    case CENTER:
    default:
      grow = 0f;
      break;
  }
  return grow;
}

public Stroke getStroke() {
  return AttributeKeys.getStroke(this);
}

public static Stroke getStroke(Figure f) {
  double strokeWidth = f.get(STROKE_WIDTH);
  float miterLimit = (float) getStrokeTotalMiterLimit(f);
  double dashFactor = f.get(IS_STROKE_DASH_FACTOR) ? strokeWidth : 1d;
  double dashPhase = f.get(STROKE_DASH_PHASE);