/*
    * 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.LayoutManager;
  
  import javax.swing.JTable;
  import javax.swing.table.TableColumn;
  import javax.swing.table.TableColumnModel;
  import javax.swing.table.TableModel;
  
  /**
   * Extension of {@link JTable} that provides different way of resizing of columns.
   *
   * @author Daniel Sendula
   */
  public class ResizingTable extends JTable {
  
      public ResizingTable(TableModel tableModel) {
          super(tableModel);
      }
  
      public void createDefaultColumnsFromModel() {
          TableModel m = getModel();
          if (m != null) {
              // Remove any current columns
              TableColumnModel cm = getColumnModel();
              while (cm.getColumnCount() > 0) {
                  cm.removeColumn(cm.getColumn(0));
              }
  
              // Create new columns from the data model info
              for (int i = 0; i < m.getColumnCount(); i++) {
                  TableColumn newColumn = new TableColumn(i) {
                      
                      protected int preferredWidth;
                      
                      public void setPreferredWidth(int width) {
                          preferredWidth = width;
                      }
                      
                      public int getPreferredWidth() {
                          return preferredWidth;
                      }
                  };
                  addColumn(newColumn);
              }
          }
      }
  
      public void doLayout() {
          TableColumn resizingColumn = getResizingColumn();
          TableColumnModel columnModel = getColumnModel();
          
          int width = getWidth();
          int columns = getColumnCount();
          int[] widths = new int[columns];
          int[] minWidths = new int[columns];
          int[] maxWidths = new int[columns];
          
          int notDefined = 0;
          int tWidth = 0;
          if (resizingColumn != null) {
              for (int i = 0; i < columns; i++) {
                  TableColumn col = columnModel.getColumn(i);
                  if (resizingColumn == col) {
                      widths[i] = col.getWidth();
                  } else {
                      if (col.getPreferredWidth() >= 0) {
                          widths[i] = col.getWidth();
                      } else {
                          widths[i] = -1;
                          notDefined = notDefined + 1;
                      }
                  }
                  minWidths[i] = col.getMinWidth();
                  maxWidths[i] = col.getMaxWidth();
                  tWidth = tWidth + widths[i];
                  if (minWidths[i] < 0) {
                      minWidths[i] = 15;
                  }
              }
          } else {
              for (int i = 0; i < columns; i++) {
                  TableColumn col = columnModel.getColumn(i);
                  widths[i] = col.getPreferredWidth();
                  minWidths[i] = col.getMinWidth();
                  maxWidths[i] = col.getMaxWidth();
                  if (widths[i] > 0) {
                     tWidth = tWidth + widths[i];
                 } else {
                     notDefined = notDefined + 1;
                 }
                 if (minWidths[i] < 0) {
                     minWidths[i] = 15;
                 }
             }
         }
         if (notDefined > 0) {
             if (tWidth < width) {
                 int nWidth = 0;
                 for (int i = 0; i < columns; i++) {
                     if (widths[i] < 0) {
                         int calc = (width - tWidth) / notDefined;
                         if (calc < minWidths[i]) {
                             calc = minWidths[i];
                         }
                         widths[i] = calc;
                         nWidth = nWidth + calc;
                         notDefined = notDefined - 1;
                     } else {
                         nWidth = nWidth + widths[i];
                     }
                 }
                 tWidth = nWidth;
             } else {
                 tWidth = 0;
                 for (int i = 0; i < columns; i++) {
                     if (widths[i] < 0) {
                         widths[i] = minWidths[i];
                     }
                     tWidth = tWidth + widths[i];
                 }
             }
         }
         if (tWidth < width) {
             // size up
             int add = width - tWidth;
             int i = 0;
             while ((i < columns) && (add > 0)) {
                 int calc = add / (columns - i);
                 if (calc == 0) {
                     calc = 1;
                 }
                 if (maxWidths[i] >= widths[i] + calc) {
                     widths[i] = widths[i] + calc;
                     add = add - calc;
                 }
                 i++;
             }
         } else if (tWidth > width) {
             // size down
             int del = tWidth - width;
             int i = 0;
             while ((i < columns) && (del > 0)) {
                 int calc = del / (columns - i);
                 if (calc == 0) {
                     calc = 1;
                 }
                 if (minWidths[i] <= widths[i] - calc) {
                     widths[i] = widths[i] - calc;
                     del = del - calc;
                 }
                 i++;
             }
         }
         for (int i = 0; i < columns; i++) {
             columnModel.getColumn(i).setWidth(widths[i]);
         }
     }
     
     
     
     
     
     public void doLayout2() {
         TableColumn resizingColumn = getResizingColumn();
         if (resizingColumn == null) {
             setWidthsFromPreferredWidths(false);
         } else {
             // JTable behaves like a layout manger - but one in which the
             // user can come along and dictate how big one of the children
             // (columns) is supposed to be.
 
             // A column has been resized and JTable may need to distribute
             // any overall delta to other columns, according to the resize mode.
             int columnIndex = viewIndexForColumn(resizingColumn);
             int delta = getWidth() - getColumnModel().getTotalColumnWidth();
             accommodateDelta(columnIndex, delta);
             delta = getWidth() - getColumnModel().getTotalColumnWidth();
 
             // If the delta cannot be completely accomodated, then the
             // resizing column will have to take any remainder. This means
             // that the column is not being allowed to take the requested
             // width. This happens under many circumstances: For example,
             // AUTO_RESIZE_NEXT_COLUMN specifies that any delta be distributed
             // to the column after the resizing column. If one were to attempt
             // to resize the last column of the table, there would be no
             // columns after it, and hence nowhere to distribute the delta.
             // It would then be given entirely back to the resizing column,
             // preventing it from changing size.
             if (delta != 0) {
                 resizingColumn.setWidth(resizingColumn.getWidth() + delta);
             }
 
             // At this point the JTable has to work out what preferred sizes
             // would have resulted in the layout the user has chosen.
             // Thereafter, during window resizing etc. it has to work off
             // the preferred sizes as usual - the idea being that, whatever
             // the user does, everything stays in synch and things don't jump
             // around.
             setWidthsFromPreferredWidths(true);
         }
 
         LayoutManager layoutMgr = getLayout();
         if (layoutMgr != null) {
             layoutMgr.layoutContainer(this);
         }
     }
 
 
     
     
     
     
     
     
     
     private TableColumn getResizingColumn() {
         return (tableHeader == null) ? null : tableHeader.getResizingColumn();
     }
 
     private void setWidthsFromPreferredWidths(final boolean inverse) {
         int totalWidth = getWidth();
         int totalPreferred = getPreferredSize().width;
         int target = !inverse ? totalWidth : totalPreferred;
 
         final TableColumnModel cm = columnModel;
         Resizable3 r = new Resizable3() {
             public int getElementCount() {
                 return cm.getColumnCount();
             }
 
             public int getLowerBoundAt(int i) {
                 return cm.getColumn(i).getMinWidth();
             }
 
             public int getUpperBoundAt(int i) {
                 return cm.getColumn(i).getMaxWidth();
             }
 
             public int getMidPointAt(int i) {
                 if (!inverse) {
                     return cm.getColumn(i).getPreferredWidth();
                 } else {
                     return cm.getColumn(i).getWidth();
                 }
             }
 
             public void setSizeAt(int s, int i) {
                 if (!inverse) {
                     cm.getColumn(i).setWidth(s);
                 } else {
                     cm.getColumn(i).setPreferredWidth(s);
                 }
             }
         };
 
         adjustSizes(target, r, inverse);
     }
 
     private int viewIndexForColumn(TableColumn aColumn) {
         TableColumnModel cm = getColumnModel();
         for (int column = 0; column < cm.getColumnCount(); column++) {
             if (cm.getColumn(column) == aColumn) {
                 return column;
             }
         }
         return -1;
     }
 
     private void accommodateDelta(int resizingColumnIndex, int delta) {
         int columnCount = getColumnCount();
         int from = resizingColumnIndex;
         int to = columnCount;
 
         // Use the mode to determine how to absorb the changes.
         switch (autoResizeMode) {
         case AUTO_RESIZE_NEXT_COLUMN:
             from = from + 1;
             to = Math.min(from + 1, columnCount);
             break;
         case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
             from = from + 1;
             to = columnCount;
             break;
         case AUTO_RESIZE_LAST_COLUMN:
             from = columnCount - 1;
             to = from + 1;
             break;
         case AUTO_RESIZE_ALL_COLUMNS:
             from = 0;
             to = columnCount;
             break;
         default:
             return;
         }
 
         final int start = from;
         final int end = to;
         final TableColumnModel cm = columnModel;
         Resizable3 r = new Resizable3() {
             public int getElementCount() {
                 return end - start;
             }
 
             public int getLowerBoundAt(int i) {
                 return cm.getColumn(i + start).getMinWidth();
             }
 
             public int getUpperBoundAt(int i) {
                 return cm.getColumn(i + start).getMaxWidth();
             }
 
             public int getMidPointAt(int i) {
                 return cm.getColumn(i + start).getWidth();
             }
 
             public void setSizeAt(int s, int i) {
                 cm.getColumn(i + start).setWidth(s);
             }
         };
 
         int totalWidth = 0;
         for (int i = from; i < to; i++) {
             TableColumn aColumn = columnModel.getColumn(i);
             int input = aColumn.getWidth();
             totalWidth = totalWidth + input;
         }
 
         adjustSizes(totalWidth + delta, r, false);
 
         return;
     }
 
     private void adjustSizes(long target, final Resizable3 r, boolean inverse) {
         int N = r.getElementCount();
         long totalPreferred = 0;
         for (int i = 0; i < N; i++) {
             totalPreferred += r.getMidPointAt(i);
         }
         Resizable2 s;
         if ((target < totalPreferred) == !inverse) {
             s = new Resizable2() {
                 public int getElementCount() {
                     return r.getElementCount();
                 }
 
                 public int getLowerBoundAt(int i) {
                     return r.getLowerBoundAt(i);
                 }
 
                 public int getUpperBoundAt(int i) {
                     return r.getMidPointAt(i);
                 }
 
                 public void setSizeAt(int newSize, int i) {
                     r.setSizeAt(newSize, i);
                 }
 
             };
         } else {
             s = new Resizable2() {
                 public int getElementCount() {
                     return r.getElementCount();
                 }
 
                 public int getLowerBoundAt(int i) {
                     return r.getMidPointAt(i);
                 }
 
                 public int getUpperBoundAt(int i) {
                     return r.getUpperBoundAt(i);
                 }
 
                 public void setSizeAt(int newSize, int i) {
                     r.setSizeAt(newSize, i);
                 }
 
             };
         }
         adjustSizes(target, s, !inverse);
     }
 
     private void adjustSizes(long target, Resizable2 r, boolean limitToRange) {
         long totalLowerBound = 0;
         long totalUpperBound = 0;
         for (int i = 0; i < r.getElementCount(); i++) {
             totalLowerBound += r.getLowerBoundAt(i);
             totalUpperBound += r.getUpperBoundAt(i);
         }
 
         if (limitToRange) {
             target = Math.min(Math.max(totalLowerBound, target),
                     totalUpperBound);
         }
 
         for (int i = 0; i < r.getElementCount(); i++) {
             int lowerBound = r.getLowerBoundAt(i);
             int upperBound = r.getUpperBoundAt(i);
             // Check for zero. This happens when the distribution of the delta
             // finishes early due to a series of "fixed" entries at the end.
             // In this case, lowerBound == upperBound, for all subsequent terms.
             int newSize;
             if (totalLowerBound == totalUpperBound) {
                 newSize = lowerBound;
             } else {
                 double f = (double) (target - totalLowerBound)
                         / (totalUpperBound - totalLowerBound);
                 newSize = (int) Math.round(lowerBound + f
                         * (upperBound - lowerBound));
                 // We'd need to round manually in an all integer version.
                 // size[i] = (int)(((totalUpperBound - target) * lowerBound +
                 // (target - totalLowerBound) *
                 // upperBound)/(totalUpperBound-totalLowerBound));
             }
             r.setSizeAt(newSize, i);
             target -= newSize;
             totalLowerBound -= lowerBound;
             totalUpperBound -= upperBound;
         }
     }
 
     private interface Resizable2 {
         public int getElementCount();
 
         public int getLowerBoundAt(int i);
 
         public int getUpperBoundAt(int i);
 
         public void setSizeAt(int newSize, int i);
     }
 
     private interface Resizable3 extends Resizable2 {
         public int getMidPointAt(int i);
     }
 
 }