/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.gui;
  
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Insets;
  import java.awt.LayoutManager2;
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * A layout that sorts elements in columns taking the largest width in a column
   * for column's width.
   * 
   * @author Daniel Sendula
   */
  public class TableFormLayout implements LayoutManager2 {
  
      /** Default horizontal gap */
      public static final int DEFAULT_HGAP = 5;
  
      /** Default vertical gap */
      public static final int DEFAULT_VGAP = 5;
  
      /** Vertical gap */
      private int vgap;
  
      /** Horizontal gap */
      private int hgap;
  
      /** Columns */
      private int columns;
  
      /** Calculated minimum width */
      private int minWidth = 0;
  
      /** Calculated minimum height */
      private int minHeight = 0;
  
      /** Calculated preferred width */
      private int preferredWidth = 0;
  
      /** Calculated preferred height */
      private int preferredHeight = 0;
  
      /** Did we calculate side? */
      private boolean sizeUnknown = true;
  
      /** Preferred widths for columns */
      int[] preferredWidths;
  
      /** Preferred heights for rows */
      int[] preferredHeights;
  
      /** Minimum widths for columns */
      int[] minWidths;
  
      /** Map of constraints */
      protected Map<Component, Object> constraints = new HashMap<Component, Object>();
  
      /**
       * Constructor
       * 
       * @param columns columns
       */
      public TableFormLayout(int columns) {
          this(columns, DEFAULT_HGAP, DEFAULT_VGAP);
      }
  
      /**
       * Constructor
       * 
       * @param columns columns
       * @param hgap horizontal gap
       * @param vgap vertical gap
       */
      public TableFormLayout(int columns, int hgap, int vgap) {
          this.columns = columns;
          this.hgap = hgap;
          this.vgap = vgap;
  
          preferredWidths = new int[columns];
          minWidths = new int[columns];
      }
  
      /**
       * Not implemented
      * 
      * @param name name
      * @param component component
      */
     public void addLayoutComponent(String name, Component comp) {
     }
 
     /**
      * Not implemented
      * 
      * @param comp component
      */
     public void removeLayoutComponent(Component comp) {
     }
 
     /**
      * Calculates size of parent container
      * 
      * @param parent parent container
      */
     private void setSizes(Container parent) {
         int nComps = parent.getComponentCount();
         Dimension d = null;
 
         preferredWidth = 0;
         preferredHeight = 0;
         minWidth = 0;
         minHeight = 0;
         int maxHeight = 0;
 
         for (int i = 0; i < columns; i++) {
             preferredWidths[i] = 0;
             minWidths[i] = 0;
         }
 
         int column = 0;
 
         int[] prefHeights = new int[100];
         int rows = 0;
 
         for (int i = 0; i < nComps; i++) {
             Component c = parent.getComponent(i);
             if (c.isVisible()) {
                 d = c.getPreferredSize();
 
                 Object constraint = constraints.get(c);
                 int span = 1;
                 if (constraint instanceof ColumnSpan) {
                     span = ((ColumnSpan) constraint).span;
                 }
 
                 if (preferredWidths[column] != 0) {
                     preferredHeight = preferredHeight + vgap;
                     minHeight = minHeight + vgap;
                 }
 
                 if (span == 1) {
                     if (d.width > preferredWidths[column]) {
                         preferredWidths[column] = d.width;
                     }
                 }
 
                 if (maxHeight < d.height) {
                     maxHeight = maxHeight + d.height;
                 }
 
                 d = c.getMinimumSize();
                 if (span == 1) {
                     if (d.width > minWidths[column]) {
                         minWidths[column] = d.width;
                     }
                 }
 
                 column = column + span;
                 if (column >= columns) {
                     column = 0;
                     prefHeights[rows] = maxHeight;
                     preferredHeight = preferredHeight + maxHeight;
                     rows = rows + 1;
                     maxHeight = 0;
                 }
             }
         }
         if (column != 0) {
             prefHeights[rows] = maxHeight;
             preferredHeight = preferredHeight + maxHeight;
             rows = rows + 1;
         }
 
         preferredHeights = new int[nComps];
         System.arraycopy(prefHeights, 0, preferredHeights, 0, rows);
 
         for (int i = 0; i < columns; i++) {
             if (i > 0) {
                 preferredWidth = preferredWidth + hgap;
                 minWidth = minWidth + hgap;
             }
             preferredWidth = preferredWidth + preferredWidths[i];
             minWidth = minWidth + minWidths[i];
         }
     }
 
     /**
      * Returns preferred layout size
      * 
      * @param parent parent container
      * @return preferred layout size
      */
     public Dimension preferredLayoutSize(Container parent) {
         Dimension dim = new Dimension(0, 0);
 
         setSizes(parent);
 
         // Always add the container's insets!
         Insets insets = parent.getInsets();
         dim.width = preferredWidth + insets.left + insets.right;
         dim.height = preferredHeight + insets.top + insets.bottom;
 
         sizeUnknown = false;
 
         return dim;
     }
 
     /**
      * Returns minimum layout size
      * 
      * @param parent parent container
      * @return minimum layout size
      */
     public Dimension minimumLayoutSize(Container parent) {
         Dimension dim = new Dimension(0, 0);
 
         // Always add the container's insets!
         Insets insets = parent.getInsets();
         dim.width = minWidth + insets.left + insets.right;
         dim.height = minHeight + insets.top + insets.bottom;
 
         sizeUnknown = false;
 
         return dim;
     }
 
     /**
      * Lays out container
      * 
      * @param parent parent container
      */
     public void layoutContainer(Container parent) {
         Insets insets = parent.getInsets();
 
         int nComps = parent.getComponentCount();
 
         int x = insets.left;
         int y = insets.top;
 
         if (sizeUnknown) {
             setSizes(parent);
         }
 
         int counter = 0;
         int row = 0;
 
         for (int i = 0; i < nComps; i++) {
             Component c = parent.getComponent(i);
             if (c.isVisible()) {
                 Dimension d = c.getPreferredSize();
 
                 Object constraint = constraints.get(c);
                 int span = 1;
                 if (constraint instanceof ColumnSpan) {
                     span = ((ColumnSpan) constraint).span;
                 }
 
                 int yo = 0;
                 if (d.height < preferredHeights[row]) {
                     yo = (preferredHeights[row] - d.height) / 2;
                 }
 
                 int pWidth = 0;
                 while ((span > 0) && (counter < columns)) {
                     span = span - 1;
                     pWidth = pWidth + preferredWidths[counter];
                     counter = counter + 1;
                     if ((counter < columns) && (span > 0)) {
                         pWidth = pWidth + hgap;
                     }
                 }
 
                 // Set the component's size and position.
                 c.setBounds(x, y + yo, pWidth, d.height);
 
                 x = x + hgap + pWidth;
 
                 if (counter >= columns) {
                     counter = 0;
                     x = insets.left;
                     y = y + vgap + preferredHeights[row];
                     row = row + 1;
                 }
             }
         }
     }
 
     /**
      * Returns number of columns
      * 
      * @return number of columns
      */
     public int getColumns() {
         return columns;
     }
 
     /**
      * Adds layout component.
      * @param comp component
      * @param constraints constraints
      */
     public void addLayoutComponent(Component comp, Object constraints) {
         if (constraints != null) {
             this.constraints.put(comp, constraints);
         }
     }
 
     /**
      * Returns <code>null</code>
      * @return <code>null</code>
      */
     public Dimension maximumLayoutSize(Container target) {
         return null;
     }
 
     /**
      * Returns 0
      * @return 0
      */
     public float getLayoutAlignmentX(Container target) {
         return 0;
     }
 
     /**
      * Returns 0
      * @return 0
      */
     public float getLayoutAlignmentY(Container target) {
         return 0;
     }
 
     /**
      * Sets sizes
      * @param target container
      */
     public void invalidateLayout(Container target) {
         setSizes(target);
     }
 
     /**
      * Class that contains column span info
      */
     public static class ColumnSpan {
         protected int span;
 
         /**
          * Constructor
          * @param span column span
          */
         public ColumnSpan(int span) {
             this.span = span;
         }
     }
 }