function tableize
(
  area,          // A DIV area full of DIV elements to be tableized.
  cellWidth,     // Width of each column.
  padding,       // Padding to keep between columns.
  tableWidth,    // Maximum width of the table.
  verticleCenter // 'true' if cells should be vertically centered.
)
{
  // Alias the first item in the array.
  var first = $(area).children().first();

  // Calculate the horizontal padding.
  // This includes the margin, border, and cell padding.
  var cellHorizontalPadding =
      $(first).outerWidth( true )
    - $(first).innerWidth()
    + parseInt( $(first).css( "padding-left" ), 10 )
    + parseInt( $(first).css( "padding-right" ), 10 )
    + padding;

  // Calculate the vertical padding.
  var cellVerticlePadding =
      $(first).outerHeight( true )
    - $(first).innerHeight()
    + parseInt( $(first).css( "padding-top" ), 10 )
    + parseInt( $(first).css( "padding-bottom" ), 10 )
    + padding;

  // Calculate the number of columns that can fit using the table width.
  var numberOfColumns;
  numberOfColumns  = tableWidth; // <- Start with the number of pixels in row.
  numberOfColumns /= cellWidth + cellHorizontalPadding; // <- Divide out images.
  numberOfColumns  = Math.floor( numberOfColumns );

  // Calculate the actual width used by the columns.
  var totalWidth;
  totalWidth  = cellWidth * numberOfColumns;
  totalWidth += cellHorizontalPadding * numberOfColumns;
  totalWidth += padding;

  // Calculate an offset to the right and left of the columns.
  // This will be used to center the columns.
  var startingOffset;
  startingOffset  = tableWidth;
  startingOffset -= totalWidth;
  startingOffset /= 2;
  startingOffset  = Math.floor( startingOffset );

  //---------------------------------
  // First loop, place items in correct column and set the width.
  // Make a list of the heights of the longest cell in each row.
  //---------------------------------
  var lastRow   = -1;
  var height    = -1;
  var rowHeight = []; // <- An array used to keep track of largest cell height in row.
  $(area).children().each
  (
    function( index )
    {
      // Calculate row and column.
      var row    = Math.floor( index / numberOfColumns );
      var column = index % numberOfColumns;

      // If the row number has changed...
      if ( row != lastRow )
      {
        // If we had a last row, save the largest cell height.
        if ( -1 != lastRow )
          rowHeight[ lastRow ] = height;

        // Reset largest height.
        height = -1;

        // Last row is now current row.
        lastRow = row;
      }

      // Figure out the location of the left side.
      var left;
      left  = column;
      left *= cellWidth + cellHorizontalPadding;
      left += padding;

      // Adjust cell's left offset and width.
      $(this)
        .css
        (
          {
            "position": "absolute",
            "left": left,
            "width": cellWidth,
            "height": "",
          }
        );

      // If also doing vertical centering...
      if ( verticleCenter )
        $(this)
          // Reset height of child.  This is for the vertical center.
          .children()
            .css
            (
              {
                "height": "",
                "width": "100%",
                "display": "table-cell",
                "vertical-align": "middle",
              }
            )
          // Width of the 2nd child.  This is for the vertical center.
          .children().children()
            .width( cellWidth );

      // Remember height of tallest cell.
      height = Math.max( $(this).height(), height );
    }
  );

  // Save height of last row.
  rowHeight[ lastRow ] = height;

  //---------------------------------
  // Second loop, set the height of all cells in a row to the cell with the tallest
  // height in that row.
  //---------------------------------
  var top = padding; // <- Accumulator for where row begins.
  lastRow = -1;
  $(area).children().each
  (
    function( index )
    {
      // Calculate row of this cell.
      var row = Math.floor( index / numberOfColumns );

      // Height to use for this row.
      var height = rowHeight[ row ];

      if ( row != lastRow )
      {
        // If row has changed and isn't the first row...
        if ( -1 != lastRow )
          // Accumulate the height to start new row.
          top += rowHeight[ lastRow ] + cellVerticlePadding;

        lastRow = row;
      }

      // Adjust cell's top location and height.
      $(this)
        .css
        (
          {
            "top": top,
            "height": height,
          }
        )

      // If also doing vertical centering...
      if ( verticleCenter )
        $(this)
          // Height of the 1st child, which will allow vertical centering.
          .children().height( height );
    }
  );

  // Add height of last row to determine height of parent cell.
  top += rowHeight[ lastRow ] + cellVerticlePadding;

  // Set height of parent cell.
  $(first).parent()
    .css
    (
      {
        "position": "relative",
        "margin": "auto",
        "width": totalWidth,
        "height": top,
      }
    );

} // tableize