// FlowLayout subclass that fully supports wrapping of components
// (showing in multiple lines)

// from https://tips4java.wordpress.com/2008/11/06/wrap-layout/

sclass WrapLayout extends FlowLayout {
  private Dimension preferredLayoutSize;
  
  bool preferredAsMinimum = false;

  /**
  * Constructs a new <code>WrapLayout</code> with a left
  * alignment and a default 5-unit horizontal and vertical gap.
  */
  *() {}

  /**
  * Constructs a new <code>FlowLayout</code> with the specified
  * alignment and a default 5-unit horizontal and vertical gap.
  * The value of the alignment argument must be one of
  * <code>WrapLayout</code>, <code>WrapLayout</code>,
  * or <code>WrapLayout</code>.
  * @param align the alignment value
  */
  public WrapLayout(int align)
  {
    super(align);
  }

  /**
  * Creates a new flow layout manager with the indicated alignment
  * and the indicated horizontal and vertical gaps.
  * <p>
  * The value of the alignment argument must be one of
  * <code>WrapLayout</code>, <code>WrapLayout</code>,
  * or <code>WrapLayout</code>.
  * @param align the alignment value
  * @param hgap the horizontal gap between components
  * @param vgap the vertical gap between components
  */
  public WrapLayout(int align, int hgap, int vgap)
  {
    super(align, hgap, vgap);
  }

  /**
  * Returns the preferred dimensions for this layout given the
  * <i>visible</i> components in the specified target container.
  * @param target the component which needs to be laid out
  * @return the preferred dimensions to lay out the
  * subcomponents of the specified container
  */
  @Override
  public Dimension preferredLayoutSize(Container target)
  {
    return layoutSize(target, true);
  }

  /**
  * Returns the minimum dimensions needed to layout the <i>visible</i>
  * components contained in the specified target container.
  * @param target the component which needs to be laid out
  * @return the minimum dimensions to lay out the
  * subcomponents of the specified container
  */
  @Override
  public Dimension minimumLayoutSize(Container target)
  {
    Dimension minimum = layoutSize(target, preferredAsMinimum);
    minimum.width -= (getHgap() + 1);
    return minimum;
  }

  /**
  * Returns the minimum or preferred dimension needed to layout the target
  * container.
  *
  * @param target target to get layout size for
  * @param preferred should preferred size be calculated
  * @return the dimension to layout the target container
  */
  private Dimension layoutSize(Container target, boolean preferred)
  {
  synchronized (target.getTreeLock())
  {
    //  Each row must fit with the width allocated to the containter.
    //  When the container width = 0, the preferred width of the container
    //  has not yet been calculated so lets ask for the maximum.

    int targetWidth = target.getSize().width;
    print ifdef WrapLayout_debug(+targetWidth);
    Container container = target;

    while (container.getSize().width == 0 && container.getParent() != null)
    {
      container = container.getParent();
    }

    targetWidth = container.getSize().width;

    if (targetWidth == 0)
      targetWidth = Integer.MAX_VALUE;

    int hgap = getHgap();
    int vgap = getVgap();
    Insets insets = target.getInsets();
    int horizontalInsetsAndGap = insets.left + insets.right + (hgap * 2);
    int maxWidth = targetWidth - horizontalInsetsAndGap;

    //  Fit components into the allowed width

    Dimension dim = new Dimension(0, 0);
    int rowWidth = 0;
    int rowHeight = 0;

    int nmembers = target.getComponentCount();

    for (int i = 0; i < nmembers; i++)
    {
      Component m = target.getComponent(i);

      if (m.isVisible())
      {
        Dimension d = preferred ? m.getPreferredSize() : m.getMinimumSize();

        //  Can't add the component to current row. Start a new row.

        if (rowWidth + d.width > maxWidth)
        {
          addRow(dim, rowWidth, rowHeight);
          rowWidth = 0;
          rowHeight = 0;
        }

        //  Add a horizontal gap for all components after the first

        if (rowWidth != 0)
        {
          rowWidth += hgap;
        }

        rowWidth += d.width;
        rowHeight = Math.max(rowHeight, d.height);
      }
    }

    addRow(dim, rowWidth, rowHeight);

    dim.width += horizontalInsetsAndGap;
    dim.height += insets.top + insets.bottom + vgap * 2;

    //  When using a scroll pane or the DecoratedLookAndFeel we need to
    //  make sure the preferred size is less than the size of the
    //  target containter so shrinking the container size works
    //  correctly. Removing the horizontal gap is an easy way to do this.

    Container scrollPane = SwingUtilities.getAncestorOfClass(JScrollPane.class, target);

    if (scrollPane != null && target.isValid())
    {
      dim.width -= (hgap + 1);
    }
    
    ifdef WrapLayout_debug
    print(renderVars("WrapLayout layoutSize", +preferred, +targetWidth, +dim));
    endifdef

    return dim;
  }
  }

  /*
   *  A new row has been completed. Use the dimensions of this row
   *  to update the preferred size for the container.
   *
   *  @param dim update the width and height when appropriate
   *  @param rowWidth the width of the row to add
   *  @param rowHeight the height of the row to add
   */
  private void addRow(Dimension dim, int rowWidth, int rowHeight)
  {
    dim.width = Math.max(dim.width, rowWidth);

    if (dim.height > 0)
    {
      dim.height += getVgap();
    }

    dim.height += rowHeight;
  }
}