/**
  * Renders using the given rendering surface and area on that surface.
  *
  * @param g the rendering surface to use
  * @param allocation the allocated region to render into
  * @see View#paint
  */
 public void paint(Graphics g, Shape allocation) {
   super.paint(g, allocation);
   Rectangle alloc = allocation.getBounds();
   Rectangle clip = g.getClipBounds();
   // Since listPainter paints in the insets we have to check for the
   // case where the child is not painted because the paint region is
   // to the left of the child. This assumes the ListPainter paints in
   // the left margin.
   if ((clip.x + clip.width) < (alloc.x + getLeftInset())) {
     Rectangle childRect = alloc;
     alloc = getInsideAllocation(allocation);
     int n = getViewCount();
     int endY = clip.y + clip.height;
     for (int i = 0; i < n; i++) {
       childRect.setBounds(alloc);
       childAllocation(i, childRect);
       if (childRect.y < endY) {
         if ((childRect.y + childRect.height) >= clip.y) {
           listPainter.paint(
               g, childRect.x, childRect.y, childRect.width, childRect.height, this, i);
         }
       } else {
         break;
       }
     }
   }
 }
  /**
   * Calculate the needs for the paragraph along the minor axis.
   *
   * <p>If size requirements are explicitly specified for the paragraph, use that requirements.
   * Otherwise, use the requirements of the superclass {@link javax.swing.text.ParagraphView}.
   *
   * <p>If the {@code axis} parameter is neither {@code View.X_AXIS} nor {@code View.Y_AXIS}, {@link
   * IllegalArgumentException} is thrown. If the {@code r} parameter is {@code null,} a new {@code
   * SizeRequirements} object is created, otherwise the supplied {@code SizeRequirements} object is
   * returned.
   *
   * @param axis the minor axis
   * @param r the input {@code SizeRequirements} object
   * @return the new or adjusted {@code SizeRequirements} object
   * @throws IllegalArgumentException if the {@code axis} parameter is invalid
   */
  protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) {
    r = super.calculateMinorAxisRequirements(axis, r);

    if (BlockView.spanSetFromAttributes(axis, r, cssWidth, cssHeight)) {
      // Offset by the margins so that pref/min/max return the
      // right value.
      int margin =
          (axis == X_AXIS) ? getLeftInset() + getRightInset() : getTopInset() + getBottomInset();
      r.minimum -= margin;
      r.preferred -= margin;
      r.maximum -= margin;
    }
    return r;
  }
 /**
  * Paints the <code>ListView</code>.
  *
  * @param g the graphics context to use for painting
  * @param allocation the allocation given to this view
  */
 public void paint(Graphics g, Shape allocation) {
   super.paint(g, allocation);
   // FIXME: Why is this overridden? I think that painting would be done
   // by the superclass and the stylesheet... Maybe find out when this
   // stuff is implemented properly.
 }
 /**
  * Fetches this view's properties from the style attributes of this view's element.
  *
  * <p>This forwards to super and then fetches a {@link StyleSheet.ListPainter} from the stylesheet
  * suitable for painting the list.
  */
 protected void setPropertiesFromAttributes() {
   super.setPropertiesFromAttributes();
   painter = getStyleSheet().getListPainter(getAttributes());
 }
 /**
  * Paints the child with the specified index into the specified allocation.
  *
  * <p>This implementation forwards to the list painter fetched from the {@link StyleSheet} and
  * then calls <code>super.paintChild(g, a, index)</code>.
  *
  * @param g the graphics context to use
  * @param a the allocation for the child
  * @param index the child index
  */
 protected void paintChild(Graphics g, Rectangle a, int index) {
   painter.paint(g, a.x, a.y, a.width, a.height, this, index);
   super.paintChild(g, a, index);
 }
 /**
  * Paints one of the children; called by paint(). By default that is all it does, but a subclass
  * can use this to paint things relative to the child.
  *
  * @param g the graphics context
  * @param alloc the allocated region to render the child into
  * @param index the index of the child
  */
 protected void paintChild(Graphics g, Rectangle alloc, int index) {
   listPainter.paint(g, alloc.x, alloc.y, alloc.width, alloc.height, this, index);
   super.paintChild(g, alloc, index);
 }