Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.swing.impl;

/*

 * Based on portions of code from "Table Column Adjuster"

 * Posted by Rob Camick on November 10, 2008 in "Java Tips Weblog"

 * https://tips4java.wordpress.com/2008/11/10/table-column-adjuster/

 */

import org.gvsig.tools.swing.api.TableColumnAdjuster;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.HashMap;

import java.util.Map;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JViewport;

import javax.swing.KeyStroke;

import javax.swing.SwingUtilities;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

/*

 *        Class to manage the widths of colunmns in a table.

 *

 *  Various properties control how the width of the column is calculated.

 *  Another property controls whether column width calculation should be dynamic.

 *  Finally, various Actions will be added to the table to allow the user

 *  to customize the functionality.

 *

 *  This class was designed to be used with tables that use an auto resize mode

 *  of AUTO_RESIZE_OFF. With all other modes you are constrained as the width

 *  of the columns must fit inside the table. So if you increase one column, one

 *  or more of the other columns must decrease. Because of this the resize mode

 *  of RESIZE_ALL_COLUMNS will work the best.

 * 

 *  Usage:

 *    

 *    TableColumnAdjuster.install(table);

 *    

 */

public class TableColumnAdjusterImpl implements PropertyChangeListener, TableModelListener, TableColumnAdjuster {

  private JTable table;

  private int spacing;

  private boolean isColumnHeaderIncluded;

  private boolean isColumnDataIncluded;

  private boolean isOnlyAdjustLarger;

  private boolean isDynamicAdjustment;

  private Map<TableColumn, Integer> columnSizes;

  private JScrollPane scrollPane;

  private int sugestedLastColumnWidth;

  private ComponentListener lastColumnAdjuster;

  /*

         *  Specify the table and use default spacing

   */

  protected TableColumnAdjusterImpl(JTable table) {

    this(table, null, 6);

  }

  /*

         *  Specify the table and spacing

   */

  @SuppressWarnings("OverridableMethodCallInConstructor")

  protected TableColumnAdjusterImpl(JTable table, JScrollPane scrollPane, int spacing) {

    this.scrollPane = scrollPane;

    this.lastColumnAdjuster = null;

    this.sugestedLastColumnWidth = 0;

    this.columnSizes = new HashMap<>();

    this.table = table;

    this.spacing = spacing;

    if( this.scrollPane==null ) {

      this.scrollPane = this.findScrollPane();

    }

    if( this.scrollPane!=null) {

      this.lastColumnAdjuster = new ComponentAdapter() {

        @Override

        public void componentResized(ComponentEvent e) {

          updateLastColumnWidth();

        }

      };

      this.scrollPane.addComponentListener(this.lastColumnAdjuster);

    }

    setColumnHeaderIncluded(true);

    setColumnDataIncluded(false);

    setOnlyAdjustLarger(false);

    setDynamicAdjustment(false);

//    installActions();

  }

  public static TableColumnAdjusterImpl install(JTable table) {

    table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

    TableColumnAdjusterImpl tca = new TableColumnAdjusterImpl(table);

    table.addPropertyChangeListener(tca);

    tca.adjustColumns();

    return tca;

  }

  @Override

  public void uninstall() {

    this.setDynamicAdjustment(false);

    if( this.lastColumnAdjuster!=null ) {

      this.table.removeComponentListener(lastColumnAdjuster);

    }

    table.removePropertyChangeListener(this);

  }

  private JScrollPane findScrollPane() {

    if (table.getParent() instanceof JViewport) {

      JViewport viewport = (JViewport) table.getParent();

      if (viewport.getParent() instanceof JScrollPane) {        

        JScrollPane sp = (JScrollPane) viewport.getParent();

        return sp;

      }

    }    

    return null;

  }

  private void updateLastColumnWidth() {

    TableColumnModel tcm = table.getColumnModel();

    if( tcm.getColumnCount()<1 ) {

      return;

    }

    if (this.sugestedLastColumnWidth < 1 ) {

      this.sugestedLastColumnWidth = tcm.getColumn(tcm.getColumnCount() - 1).getWidth();

    }

    int with = 0;

    int lastColumn = tcm.getColumnCount() - 1;

    for (int i = 0; i < lastColumn; i++) {

      with += tcm.getColumn(i).getWidth();

    }

    int visibleWith = scrollPane.getWidth();

    if (scrollPane.getVerticalScrollBar().isVisible()) {

      visibleWith -= scrollPane.getVerticalScrollBar().getWidth();

    }

    if (visibleWith > with + this.sugestedLastColumnWidth) {

      int lastColumnWidth = visibleWith - with;

      tcm.getColumn(lastColumn).setWidth(lastColumnWidth);

    } else {

      tcm.getColumn(lastColumn).setWidth(this.sugestedLastColumnWidth);

    }

    table.getTableHeader().setResizingColumn(tcm.getColumn(lastColumn));

  }

  /*

         *  Adjust the widths of all the columns in the table

   */

  @Override

  public void adjustColumns() {

    TableColumnModel tcm = table.getColumnModel();

    for (int i = 0; i < tcm.getColumnCount(); i++) {

      adjustColumn(i);

    }

  }

  /*

         *  Adjust the width of the specified column in the table

   */

  @Override

  public void adjustColumn(final int column) {

    TableColumn tableColumn = table.getColumnModel().getColumn(column);

    if (!tableColumn.getResizable()) {

      return;

    }

    int columnHeaderWidth = getColumnHeaderWidth(column);

    int columnDataWidth = getColumnDataWidth(column);

    int preferredWidth = Math.max(columnHeaderWidth, columnDataWidth);

    updateTableColumn(column, preferredWidth);

  }

  /*

         *  Calculated the width based on the column name

   */

  private int getColumnHeaderWidth(int column) {

    if (!isColumnHeaderIncluded) {

      return 0;

    }

    TableColumn tableColumn = table.getColumnModel().getColumn(column);

    Object value = tableColumn.getHeaderValue();

    TableCellRenderer renderer = tableColumn.getHeaderRenderer();

    if (renderer == null) {

      renderer = table.getTableHeader().getDefaultRenderer();

    }

    Component c = renderer.getTableCellRendererComponent(table, value, false, false, -1, column);

    return c.getPreferredSize().width;

  }

  /*

         *  Calculate the width based on the widest cell renderer for the

         *  given column.

   */

  private int getColumnDataWidth(int column) {

    if (!isColumnDataIncluded) {

      return 0;

    }

    int preferredWidth = 0;

    int maxWidth = table.getColumnModel().getColumn(column).getMaxWidth();

    for (int row = 0; row < table.getRowCount(); row++) {

      preferredWidth = Math.max(preferredWidth, getCellDataWidth(row, column));

      //  We've exceeded the maximum width, no need to check other rows

      if (preferredWidth >= maxWidth) {

        break;

      }

    }

    return preferredWidth;

  }

  /*

         *  Get the preferred width for the specified cell

   */

  private int getCellDataWidth(int row, int column) {

    //  Inovke the renderer for the cell to calculate the preferred width

    TableCellRenderer cellRenderer = table.getCellRenderer(row, column);

    Component c = table.prepareRenderer(cellRenderer, row, column);

    int width = c.getPreferredSize().width + table.getIntercellSpacing().width;

    return width;

  }

  /*

         *  Update the TableColumn with the newly calculated width

   */

  private void updateTableColumn(int column, int width) {

    final TableColumn tableColumn = table.getColumnModel().getColumn(column);

    if (!tableColumn.getResizable()) {

      return;

    }

    width += spacing;

    //  Don't shrink the column width

    if (isOnlyAdjustLarger) {

      width = Math.max(width, tableColumn.getPreferredWidth());

    }

    columnSizes.put(tableColumn, tableColumn.getWidth());

    table.getTableHeader().setResizingColumn(tableColumn);

    tableColumn.setWidth(width);

  }

  /*

         *  Restore the widths of the columns in the table to its previous width

   */

  @Override

  public void restoreColumns() {

    TableColumnModel tcm = table.getColumnModel();

    for (int i = 0; i < tcm.getColumnCount(); i++) {

      restoreColumn(i);

    }

  }

  /*

         *  Restore the width of the specified column to its previous width

   */

  private void restoreColumn(int column) {

    TableColumn tableColumn = table.getColumnModel().getColumn(column);

    Integer width = columnSizes.get(tableColumn);

    if (width != null) {

      table.getTableHeader().setResizingColumn(tableColumn);

      tableColumn.setWidth(width);

    }

  }

  /*

         *        Indicates whether to include the header in the width calculation

   */

  @Override

  public TableColumnAdjusterImpl setColumnHeaderIncluded(boolean isColumnHeaderIncluded) {

    this.isColumnHeaderIncluded = isColumnHeaderIncluded;

    return this;

  }

  /*

         *        Indicates whether to include the model data in the width calculation

   */

  @Override

  public TableColumnAdjusterImpl setColumnDataIncluded(boolean isColumnDataIncluded) {

    this.isColumnDataIncluded = isColumnDataIncluded;

    return this;

  }

  /*

         *        Indicates whether columns can only be increased in size

   */

  @Override

  public TableColumnAdjusterImpl setOnlyAdjustLarger(boolean isOnlyAdjustLarger) {

    this.isOnlyAdjustLarger = isOnlyAdjustLarger;

    return this;

  }

  /*

         *  Indicate whether changes to the model should cause the width to be

         *  dynamically recalculated.

   */

  @Override

  public TableColumnAdjusterImpl setDynamicAdjustment(boolean isDynamicAdjustment) {

    //  May need to add or remove the TableModelListener when changed

    if (this.isDynamicAdjustment != isDynamicAdjustment) {

      if (isDynamicAdjustment) {

        table.getModel().addTableModelListener(this);

      } else {

        table.getModel().removeTableModelListener(this);

      }

    }

    this.isDynamicAdjustment = isDynamicAdjustment;

    return this;

  }

  //

  //  Implement the PropertyChangeListener

  //

  @Override

  public void propertyChange(PropertyChangeEvent e) {

    //  When the TableModel changes we need to update the listeners

    //  and column widths

    if ("model".equals(e.getPropertyName())) {

      if (isDynamicAdjustment) {

        TableModel model = (TableModel) e.getOldValue();

        model.removeTableModelListener(this);

        model = (TableModel) e.getNewValue();

        model.addTableModelListener(this);

      }

      adjustColumns();

    }

  }

  //

  //  Implement the TableModelListener

  //

  @Override

  public void tableChanged(TableModelEvent e) {

    if (!isColumnDataIncluded) {

      return;

    }

    //  Needed when table is sorted.

    SwingUtilities.invokeLater(() -> {

      //  A cell has been updated

      int column = table.convertColumnIndexToView(e.getColumn());

      if (e.getType() == TableModelEvent.UPDATE && column != -1) {

        //  Only need to worry about an increase in width for this cell

        if (isOnlyAdjustLarger) {

          int row = e.getFirstRow();

          TableColumn tableColumn = table.getColumnModel().getColumn(column);

          if (tableColumn.getResizable()) {

            int width = getCellDataWidth(row, column);

            updateTableColumn(column, width);

          }

        } //        Could be an increase of decrease so check all rows

        else {

          adjustColumn(column);

        }

      } //  The update affected more than one column so adjust all columns

      else {

        adjustColumns();

      }

    });

  }

  /*

         *  Install Actions to give user control of certain functionality.

   */

  private void installActions() {

    installColumnAction(true, true, "adjustColumn", "control ADD");

    installColumnAction(false, true, "adjustColumns", "control shift ADD");

    installColumnAction(true, false, "restoreColumn", "control SUBTRACT");

    installColumnAction(false, false, "restoreColumns", "control shift SUBTRACT");

    installToggleAction(true, false, "toggleDynamic", "control MULTIPLY");

    installToggleAction(false, true, "toggleLarger", "control DIVIDE");

  }

  /*

         *  Update the input and action maps with a new ColumnAction

   */

  private void installColumnAction(

          boolean isSelectedColumn, boolean isAdjust, String key, String keyStroke) {

    Action action = new ColumnAction(isSelectedColumn, isAdjust);

    KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);

    table.getInputMap().put(ks, key);

    table.getActionMap().put(key, action);

  }

  /*

         *  Update the input and action maps with new ToggleAction

   */

  private void installToggleAction(

          boolean isToggleDynamic, boolean isToggleLarger, String key, String keyStroke) {

    Action action = new ToggleAction(isToggleDynamic, isToggleLarger);

    KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);

    table.getInputMap().put(ks, key);

    table.getActionMap().put(key, action);

  }

  /*

         *  Action to adjust or restore the width of a single column or all columns

   */

  class ColumnAction extends AbstractAction {

    private final boolean isSelectedColumn;

    private final boolean isAdjust;

    public ColumnAction(boolean isSelectedColumn, boolean isAdjust) {

      this.isSelectedColumn = isSelectedColumn;

      this.isAdjust = isAdjust;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

      //  Handle selected column(s) width change actions

      if (isSelectedColumn) {

        int[] columns = table.getSelectedColumns();

        for (int i = 0; i < columns.length; i++) {

          if (isAdjust) {

            adjustColumn(columns[i]);

          } else {

            restoreColumn(columns[i]);

          }

        }

      } else {

        if (isAdjust) {

          adjustColumns();

        } else {

          restoreColumns();

        }

      }

    }

  }

  /*

         *  Toggle properties of the TableColumnAdjuster so the user can

         *  customize the functionality to their preferences

   */

  class ToggleAction extends AbstractAction {

    private final boolean isToggleDynamic;

    private final boolean isToggleLarger;

    public ToggleAction(boolean isToggleDynamic, boolean isToggleLarger) {

      this.isToggleDynamic = isToggleDynamic;

      this.isToggleLarger = isToggleLarger;

    }

    @Override

    @SuppressWarnings("UnnecessaryReturnStatement")

    public void actionPerformed(ActionEvent e) {

      if (isToggleDynamic) {

        setDynamicAdjustment(!isDynamicAdjustment);

        return;

      }

      if (isToggleLarger) {

        setOnlyAdjustLarger(!isOnlyAdjustLarger);

        return;

      }

    }

  }

}