       1 /*
       2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
       3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       4  *
       5  * This code is free software; you can redistribute it and/or modify it
       6  * under the terms of the GNU General Public License version 2 only, as
       7  * published by the Free Software Foundation.  Oracle designates this
       8  * particular file as subject to the "Classpath" exception as provided
       9  * by Oracle in the LICENSE file that accompanied this code.
      10  *
      11  * This code is distributed in the hope that it will be useful, but WITHOUT
      12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14  * version 2 for more details (a copy is included in the LICENSE file that
      15  * accompanied this code).
      16  *
      17  * You should have received a copy of the GNU General Public License version
      18  * 2 along with this work; if not, write to the Free Software Foundation,
      19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
      20  *
      21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
      22  * or visit www.oracle.com if you need additional information or have any
      23  * questions.
      24  */
      25
      26 package javax.swing.table;
      27
      28 import javax.swing.*;
      29 import javax.swing.event.*;
      30 import java.awt.*;
      31 import java.util.Vector;
      32 import java.util.Enumeration;
      33 import java.util.EventListener;
      34 import java.beans.PropertyChangeListener;
      35 import java.beans.PropertyChangeEvent;
      36 import java.io.Serializable;
      37 import sun.swing.SwingUtilities2;
      38
      39 /**
      40  * The standard column-handler for a <code>JTable</code>.
      41  * <p>
      42  * <strong>Warning:</strong>
      43  * Serialized objects of this class will not be compatible with
      44  * future Swing releases. The current serialization support is
      45  * appropriate for short term storage or RMI between applications running
      46  * the same version of Swing.  As of 1.4, support for long term storage
      47  * of all JavaBeans&trade;
      48  * has been added to the <code>java.beans</code> package.
      49  * Please see {@link java.beans.XMLEncoder}.
      50  *
      51  * @author Alan Chung
      52  * @author Philip Milne
      53  * @see JTable
      54  */
      55 @SuppressWarnings("serial") // Same-version serialization only
      56 public class DefaultTableColumnModel implements TableColumnModel,
      57                         PropertyChangeListener, ListSelectionListener, Serializable
      58 {
      59 //
      60 // Instance Variables
      61 //
      62
      63     /** Array of TableColumn objects in this model */
      64     protected Vector<TableColumn> tableColumns;
      65
      66     /** Model for keeping track of column selections */
      67     protected ListSelectionModel selectionModel;
      68
      69     /** Width margin between each column */
      70     protected int columnMargin;
      71
      72     /** List of TableColumnModelListener */
      73     protected EventListenerList listenerList = new EventListenerList();
      74
      75     /** Change event (only one needed) */
      76     protected transient ChangeEvent changeEvent = null;
      77
      78     /** Column selection allowed in this column model */
      79     protected boolean columnSelectionAllowed;
      80
      81     /** A local cache of the combined width of all columns */
      82     protected int totalColumnWidth;
      83
      84 //
      85 // Constructors
      86 //
      87     /**
      88      * Creates a default table column model.
      89      */
      90     public DefaultTableColumnModel() {
      91         super();
      92
      93         // Initialize local ivars to default
      94         tableColumns = new Vector<TableColumn>();
      95         setSelectionModel(createSelectionModel());
      96         setColumnMargin(1);
      97         invalidateWidthCache();
      98         setColumnSelectionAllowed(false);
      99     }
     100
     101 //
     102 // Modifying the model
     103 //
     104
     105     /**
     106      *  Appends <code>aColumn</code> to the end of the
     107      *  <code>tableColumns</code> array.
     108      *  This method also posts the <code>columnAdded</code>
     109      *  event to its listeners.
     110      *
     111      * @param   aColumn         the <code>TableColumn</code> to be added
     112      * @exception IllegalArgumentException      if <code>aColumn</code> is
     113      *                          <code>null</code>
     114      * @see     #removeColumn
     115      */
     116     public void addColumn(TableColumn aColumn) {
     117         if (aColumn == null) {
     118             throw new IllegalArgumentException("Object is null");
     119         }
     120
     121         tableColumns.addElement(aColumn);
     122         aColumn.addPropertyChangeListener(this);
     123         invalidateWidthCache();
     124
     125         // Post columnAdded event notification
     126         fireColumnAdded(new TableColumnModelEvent(this, 0,
     127                                                   getColumnCount() - 1));
     128     }
     129
     130     /**
     131      *  Deletes the <code>column</code> from the
     132      *  <code>tableColumns</code> array.  This method will do nothing if
     133      *  <code>column</code> is not in the table's columns list.
     134      *  <code>tile</code> is called
     135      *  to resize both the header and table views.
     136      *  This method also posts a <code>columnRemoved</code>
     137      *  event to its listeners.
     138      *
     139      * @param   column          the <code>TableColumn</code> to be removed
     140      * @see     #addColumn
     141      */
     142     public void removeColumn(TableColumn column) {
     143         int columnIndex = tableColumns.indexOf(column);
     144
     145         if (columnIndex != -1) {
     146             // Adjust for the selection
     147             if (selectionModel != null) {
     148                 selectionModel.removeIndexInterval(columnIndex,columnIndex);
     149             }
     150
     151             column.removePropertyChangeListener(this);
     152             tableColumns.removeElementAt(columnIndex);
     153             invalidateWidthCache();
     154
     155             // Post columnAdded event notification.  (JTable and JTableHeader
     156             // listens so they can adjust size and redraw)
     157             fireColumnRemoved(new TableColumnModelEvent(this,
     158                                            columnIndex, 0));
     159         }
     160     }
     161
     162     /**
     163      * Moves the column and heading at <code>columnIndex</code> to
     164      * <code>newIndex</code>.  The old column at <code>columnIndex</code>
     165      * will now be found at <code>newIndex</code>.  The column
     166      * that used to be at <code>newIndex</code> is shifted
     167      * left or right to make room.  This will not move any columns if
     168      * <code>columnIndex</code> equals <code>newIndex</code>.  This method
     169      * also posts a <code>columnMoved</code> event to its listeners.
     170      *
     171      * @param   columnIndex                     the index of column to be moved
     172      * @param   newIndex                        new index to move the column
     173      * @exception IllegalArgumentException      if <code>column</code> or
     174      *                                          <code>newIndex</code>
     175      *                                          are not in the valid range
     176      */
     177     public void moveColumn(int columnIndex, int newIndex) {
     178         if ((columnIndex < 0) || (columnIndex >= getColumnCount()) ||
     179             (newIndex < 0) || (newIndex >= getColumnCount()))
     180             throw new IllegalArgumentException("moveColumn() - Index out of range");
     181
     182         TableColumn aColumn;
     183
     184         // If the column has not yet moved far enough to change positions
     185         // post the event anyway, the "draggedDistance" property of the
     186         // tableHeader will say how far the column has been dragged.
     187         // Here we are really trying to get the best out of an
     188         // API that could do with some rethinking. We preserve backward
     189         // compatibility by slightly bending the meaning of these methods.
     190         if (columnIndex == newIndex) {
     191             fireColumnMoved(new TableColumnModelEvent(this, columnIndex, newIndex));
     192             return;
     193         }
     194         aColumn = tableColumns.elementAt(columnIndex);
     195
     196         tableColumns.removeElementAt(columnIndex);
     197         boolean selected = selectionModel.isSelectedIndex(columnIndex);
     198         selectionModel.removeIndexInterval(columnIndex,columnIndex);
     199
     200         tableColumns.insertElementAt(aColumn, newIndex);
     201         selectionModel.insertIndexInterval(newIndex, 1, true);
     202         if (selected) {
     203             selectionModel.addSelectionInterval(newIndex, newIndex);
     204         }
     205         else {
     206             selectionModel.removeSelectionInterval(newIndex, newIndex);
     207         }
     208
     209         fireColumnMoved(new TableColumnModelEvent(this, columnIndex,
     210                                                                newIndex));
     211     }
     212
     213     /**
     214      * Sets the column margin to <code>newMargin</code>.  This method
     215      * also posts a <code>columnMarginChanged</code> event to its
     216      * listeners.
     217      *
     218      * @param   newMargin               the new margin width, in pixels
     219      * @see     #getColumnMargin
     220      * @see     #getTotalColumnWidth
     221      */
     222     public void setColumnMargin(int newMargin) {
     223         if (newMargin != columnMargin) {
     224             columnMargin = newMargin;
     225             // Post columnMarginChanged event notification.
     226             fireColumnMarginChanged();
     227         }
     228     }
     229
     230 //
     231 // Querying the model
     232 //
     233
     234     /**
     235      * Returns the number of columns in the <code>tableColumns</code> array.
     236      *
     237      * @return  the number of columns in the <code>tableColumns</code> array
     238      * @see     #getColumns
     239      */
     240     public int getColumnCount() {
     241         return tableColumns.size();
     242     }
     243
     244     /**
     245      * Returns an <code>Enumeration</code> of all the columns in the model.
     246      * @return an <code>Enumeration</code> of the columns in the model
     247      */
     248     public Enumeration<TableColumn> getColumns() {
     249         return tableColumns.elements();
     250     }
     251
     252     /**
     253      * Returns the index of the first column in the <code>tableColumns</code>
     254      * array whose identifier is equal to <code>identifier</code>,
     255      * when compared using <code>equals</code>.
     256      *
     257      * @param           identifier              the identifier object
     258      * @return          the index of the first column in the
     259      *                  <code>tableColumns</code> array whose identifier
     260      *                  is equal to <code>identifier</code>
     261      * @exception       IllegalArgumentException  if <code>identifier</code>
     262      *                          is <code>null</code>, or if no
     263      *                          <code>TableColumn</code> has this
     264      *                          <code>identifier</code>
     265      * @see             #getColumn
     266      */
     267     public int getColumnIndex(Object identifier) {
     268         if (identifier == null) {
     269             throw new IllegalArgumentException("Identifier is null");
     270         }
     271
     272         Enumeration<TableColumn> enumeration = getColumns();
     273         TableColumn aColumn;
     274         int index = 0;
     275
     276         while (enumeration.hasMoreElements()) {
     277             aColumn = enumeration.nextElement();
     278             // Compare them this way in case the column's identifier is null.
     279             if (identifier.equals(aColumn.getIdentifier()))
     280                 return index;
     281             index++;
     282         }
     283         throw new IllegalArgumentException("Identifier not found");
     284     }
     285
     286     /**
     287      * Returns the <code>TableColumn</code> object for the column
     288      * at <code>columnIndex</code>.
     289      *
     290      * @param   columnIndex     the index of the column desired
     291      * @return  the <code>TableColumn</code> object for the column
     292      *                          at <code>columnIndex</code>
     293      */
     294     public TableColumn getColumn(int columnIndex) {
     295         return tableColumns.elementAt(columnIndex);
     296     }
     297
     298     /**
     299      * Returns the width margin for <code>TableColumn</code>.
     300      * The default <code>columnMargin</code> is 1.
     301      *
     302      * @return  the maximum width for the <code>TableColumn</code>
     303      * @see     #setColumnMargin
     304      */
     305     public int getColumnMargin() {
     306         return columnMargin;
     307     }
     308
     309     /**
     310      * Returns the index of the column that lies at position <code>x</code>,
     311      * or -1 if no column covers this point.
     312      *
     313      * In keeping with Swing's separable model architecture, a
     314      * TableColumnModel does not know how the table columns actually appear on
     315      * screen.  The visual presentation of the columns is the responsibility
     316      * of the view/controller object using this model (typically JTable).  The
     317      * view/controller need not display the columns sequentially from left to
     318      * right.  For example, columns could be displayed from right to left to
     319      * accommodate a locale preference or some columns might be hidden at the
     320      * request of the user.  Because the model does not know how the columns
     321      * are laid out on screen, the given <code>xPosition</code> should not be
     322      * considered to be a coordinate in 2D graphics space.  Instead, it should
     323      * be considered to be a width from the start of the first column in the
     324      * model.  If the column index for a given X coordinate in 2D space is
     325      * required, <code>JTable.columnAtPoint</code> can be used instead.
     326      *
     327      * @param  x  the horizontal location of interest
     328      * @return  the index of the column or -1 if no column is found
     329      * @see javax.swing.JTable#columnAtPoint
     330      */
     331     public int getColumnIndexAtX(int x) {
     332         if (x < 0) {
     333             return -1;
     334         }
     335         int cc = getColumnCount();
     336         for(int column = 0; column < cc; column++) {
     337             x = x - getColumn(column).getWidth();
     338             if (x < 0) {
     339                 return column;
     340             }
     341         }
     342         return -1;
     343     }
     344
     345     /**
     346      * Returns the total combined width of all columns.
     347      * @return the <code>totalColumnWidth</code> property
     348      */
     349     public int getTotalColumnWidth() {
     350         if (totalColumnWidth == -1) {
     351             recalcWidthCache();
     352         }
     353         return totalColumnWidth;
     354     }
     355
     356 //
     357 // Selection model
     358 //
     359
     360     /**
     361      *  Sets the selection model for this <code>TableColumnModel</code>
     362      *  to <code>newModel</code>
     363      *  and registers for listener notifications from the new selection
     364      *  model.  If <code>newModel</code> is <code>null</code>,
     365      *  an exception is thrown.
     366      *
     367      * @param   newModel        the new selection model
     368      * @exception IllegalArgumentException      if <code>newModel</code>
     369      *                                          is <code>null</code>
     370      * @see     #getSelectionModel
     371      */
     372     public void setSelectionModel(ListSelectionModel newModel) {
     373         if (newModel == null) {
     374             throw new IllegalArgumentException("Cannot set a null SelectionModel");
     375         }
     376
     377         ListSelectionModel oldModel = selectionModel;
     378
     379         if (newModel != oldModel) {
     380             if (oldModel != null) {
     381                 oldModel.removeListSelectionListener(this);
     382             }
     383
     384             selectionModel= newModel;
     385             newModel.addListSelectionListener(this);
     386         }
     387     }
     388
     389     /**
     390      * Returns the <code>ListSelectionModel</code> that is used to
     391      * maintain column selection state.
     392      *
     393      * @return  the object that provides column selection state.  Or
     394      *          <code>null</code> if row selection is not allowed.
     395      * @see     #setSelectionModel
     396      */
     397     public ListSelectionModel getSelectionModel() {
     398         return selectionModel;
     399     }
     400
     401     // implements javax.swing.table.TableColumnModel
     402     /**
     403      * Sets whether column selection is allowed.  The default is false.
     404      * @param  flag true if column selection will be allowed, false otherwise
     405      */
     406     public void setColumnSelectionAllowed(boolean flag) {
     407         columnSelectionAllowed = flag;
     408     }
     409
     410     // implements javax.swing.table.TableColumnModel
     411     /**
     412      * Returns true if column selection is allowed, otherwise false.
     413      * The default is false.
     414      * @return the <code>columnSelectionAllowed</code> property
     415      */
     416     public boolean getColumnSelectionAllowed() {
     417         return columnSelectionAllowed;
     418     }
     419
     420     // implements javax.swing.table.TableColumnModel
     421     /**
     422      * Returns an array of selected columns.  If <code>selectionModel</code>
     423      * is <code>null</code>, returns an empty array.
     424      * @return an array of selected columns or an empty array if nothing
     425      *                  is selected or the <code>selectionModel</code> is
     426      *                  <code>null</code>
     427      */
     428     public int[] getSelectedColumns() {
     429         if (selectionModel != null) {
     430             return selectionModel.getSelectedIndices();

     431         }
     432         return  new int[0];
     433     }
     434
     435     // implements javax.swing.table.TableColumnModel
     436     /**
     437      * Returns the number of columns selected.
     438      * @return the number of columns selected
     439      */
     440     public int getSelectedColumnCount() {
     441         if (selectionModel != null) {
     442             return selectionModel.getSelectedItemsCount();

     443         }
     444         return 0;
     445     }
     446
     447 //
     448 // Listener Support Methods
     449 //
     450
     451     // implements javax.swing.table.TableColumnModel
     452     /**
     453      * Adds a listener for table column model events.
     454      * @param x  a <code>TableColumnModelListener</code> object
     455      */
     456     public void addColumnModelListener(TableColumnModelListener x) {
     457         listenerList.add(TableColumnModelListener.class, x);
     458     }
     459
     460     // implements javax.swing.table.TableColumnModel
     461     /**
     462      * Removes a listener for table column model events.
     463      * @param x  a <code>TableColumnModelListener</code> object
     464      */
     465     public void removeColumnModelListener(TableColumnModelListener x) {
     466         listenerList.remove(TableColumnModelListener.class, x);
     467     }
     468
     469     /**
     470      * Returns an array of all the column model listeners
     471      * registered on this model.
     472      *
     473      * @return all of this default table column model's <code>ColumnModelListener</code>s
     474      *         or an empty
     475      *         array if no column model listeners are currently registered
     476      *
     477      * @see #addColumnModelListener
     478      * @see #removeColumnModelListener
     479      *
     480      * @since 1.4
     481      */
     482     public TableColumnModelListener[] getColumnModelListeners() {
     483         return listenerList.getListeners(TableColumnModelListener.class);
     484     }
     485
     486 //
     487 //   Event firing methods
     488 //
     489
     490     /**
     491      * Notifies all listeners that have registered interest for
     492      * notification on this event type.  The event instance
     493      * is lazily created using the parameters passed into
     494      * the fire method.
     495      * @param e  the event received
     496      * @see EventListenerList
     497      */
     498     protected void fireColumnAdded(TableColumnModelEvent e) {
     499         // Guaranteed to return a non-null array
     500         Object[] listeners = listenerList.getListenerList();
     501         // Process the listeners last to first, notifying
     502         // those that are interested in this event
     503         for (int i = listeners.length-2; i>=0; i-=2) {
     504             if (listeners[i]==TableColumnModelListener.class) {
     505                 // Lazily create the event:
     506                 // if (e == null)
     507                 //  e = new ChangeEvent(this);
     508                 ((TableColumnModelListener)listeners[i+1]).
     509                     columnAdded(e);
     510             }
     511         }
     512     }
     513
     514     /**
     515      * Notifies all listeners that have registered interest for
     516      * notification on this event type.  The event instance
     517      * is lazily created using the parameters passed into
     518      * the fire method.
     519      * @param  e  the event received
     520      * @see EventListenerList
     521      */
     522     protected void fireColumnRemoved(TableColumnModelEvent e) {
     523         // Guaranteed to return a non-null array
     524         Object[] listeners = listenerList.getListenerList();
     525         // Process the listeners last to first, notifying
     526         // those that are interested in this event
     527         for (int i = listeners.length-2; i>=0; i-=2) {
     528             if (listeners[i]==TableColumnModelListener.class) {
     529                 // Lazily create the event:
     530                 // if (e == null)
     531                 //  e = new ChangeEvent(this);
     532                 ((TableColumnModelListener)listeners[i+1]).
     533                     columnRemoved(e);
     534             }
     535         }
     536     }
     537
     538     /**
     539      * Notifies all listeners that have registered interest for
     540      * notification on this event type.  The event instance
     541      * is lazily created using the parameters passed into
     542      * the fire method.
     543      * @param  e the event received
     544      * @see EventListenerList
     545      */
     546     protected void fireColumnMoved(TableColumnModelEvent e) {
     547         // Guaranteed to return a non-null array
     548         Object[] listeners = listenerList.getListenerList();
     549         // Process the listeners last to first, notifying
     550         // those that are interested in this event
     551         for (int i = listeners.length-2; i>=0; i-=2) {
     552             if (listeners[i]==TableColumnModelListener.class) {
     553                 // Lazily create the event:
     554                 // if (e == null)
     555                 //  e = new ChangeEvent(this);
     556                 ((TableColumnModelListener)listeners[i+1]).
     557                     columnMoved(e);
     558             }
     559         }
     560     }
     561
     562     /**
     563      * Notifies all listeners that have registered interest for
     564      * notification on this event type.  The event instance
     565      * is lazily created using the parameters passed into
     566      * the fire method.
     567      * @param e the event received
     568      * @see EventListenerList
     569      */
     570     protected void fireColumnSelectionChanged(ListSelectionEvent e) {
     571         // Guaranteed to return a non-null array
     572         Object[] listeners = listenerList.getListenerList();
     573         // Process the listeners last to first, notifying
     574         // those that are interested in this event
     575         for (int i = listeners.length-2; i>=0; i-=2) {
     576             if (listeners[i]==TableColumnModelListener.class) {
     577                 // Lazily create the event:
     578                 // if (e == null)
     579                 //  e = new ChangeEvent(this);
     580                 ((TableColumnModelListener)listeners[i+1]).
     581                     columnSelectionChanged(e);
     582             }
     583         }
     584     }
     585
     586     /**
     587      * Notifies all listeners that have registered interest for
     588      * notification on this event type.  The event instance
     589      * is lazily created using the parameters passed into
     590      * the fire method.
     591      * @see EventListenerList
     592      */
     593     protected void fireColumnMarginChanged() {
     594         // Guaranteed to return a non-null array
     595         Object[] listeners = listenerList.getListenerList();
     596         // Process the listeners last to first, notifying
     597         // those that are interested in this event
     598         for (int i = listeners.length-2; i>=0; i-=2) {
     599             if (listeners[i]==TableColumnModelListener.class) {
     600                 // Lazily create the event:
     601                 if (changeEvent == null)
     602                     changeEvent = new ChangeEvent(this);
     603                 ((TableColumnModelListener)listeners[i+1]).
     604                     columnMarginChanged(changeEvent);
     605             }
     606         }
     607     }
     608
     609     /**
     610      * Returns an array of all the objects currently registered
     611      * as <code><em>Foo</em>Listener</code>s
     612      * upon this model.
     613      * <code><em>Foo</em>Listener</code>s are registered using the
     614      * <code>add<em>Foo</em>Listener</code> method.
     615      *
     616      * <p>
     617      *
     618      * You can specify the <code>listenerType</code> argument
     619      * with a class literal,
     620      * such as
     621      * <code><em>Foo</em>Listener.class</code>.
     622      * For example, you can query a
     623      * <code>DefaultTableColumnModel</code> <code>m</code>
     624      * for its column model listeners with the following code:
     625      *
     626      * <pre>ColumnModelListener[] cmls = (ColumnModelListener[])(m.getListeners(ColumnModelListener.class));</pre>
     627      *
     628      * If no such listeners exist, this method returns an empty array.
     629      *
     630      * @param <T> the listener type
     631      * @param listenerType the type of listeners requested
     632      * @return an array of all objects registered as
     633      *          <code><em>Foo</em>Listener</code>s on this model,
     634      *          or an empty array if no such
     635      *          listeners have been added
     636      * @exception ClassCastException if <code>listenerType</code>
     637      *          doesn't specify a class or interface that implements
     638      *          <code>java.util.EventListener</code>
     639      *
     640      * @see #getColumnModelListeners
     641      * @since 1.3
     642      */
     643     public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
     644         return listenerList.getListeners(listenerType);
     645     }
     646
     647 //
     648 // Implementing the PropertyChangeListener interface
     649 //
     650
     651     // PENDING(alan)
     652     // implements java.beans.PropertyChangeListener
     653     /**
     654      * Property Change Listener change method.  Used to track changes
     655      * to the column width or preferred column width.
     656      *
     657      * @param  evt  <code>PropertyChangeEvent</code>
     658      */
     659     public void propertyChange(PropertyChangeEvent evt) {
     660         String name = evt.getPropertyName();
     661
     662         if (name == "width" || name == "preferredWidth") {
     663             invalidateWidthCache();
     664             // This is a misnomer, we're using this method
     665             // simply to cause a relayout.
     666             fireColumnMarginChanged();
     667         }
     668
     669     }
     670
     671 //
     672 // Implementing ListSelectionListener interface
     673 //
     674
     675     // implements javax.swing.event.ListSelectionListener
     676     /**
     677      * A <code>ListSelectionListener</code> that forwards
     678      * <code>ListSelectionEvents</code> when there is a column
     679      * selection change.
     680      *
     681      * @param e  the change event
     682      */
     683     public void valueChanged(ListSelectionEvent e) {
     684         fireColumnSelectionChanged(e);
     685     }
     686
     687 //
     688 // Protected Methods
     689 //
     690
     691     /**
     692      * Creates a new default list selection model.
     693      *
     694      * @return a newly created default list selection model.
     695      */
     696     protected ListSelectionModel createSelectionModel() {
     697         return new DefaultListSelectionModel();
     698     }
     699
     700     /**
     701      * Recalculates the total combined width of all columns.  Updates the
     702      * <code>totalColumnWidth</code> property.
     703      */
     704     protected void recalcWidthCache() {
     705         Enumeration<TableColumn> enumeration = getColumns();
     706         totalColumnWidth = 0;
     707         while (enumeration.hasMoreElements()) {
     708             totalColumnWidth += enumeration.nextElement().getWidth();
     709         }
     710     }
     711
     712     private void invalidateWidthCache() {
     713         totalColumnWidth = -1;
     714     }
     715
     716 } // End of class DefaultTableColumnModel
    --- EOF ---