libjava/javax/swing/table/DefaultTableColumnModel.java

   1 /* DefaultTableColumnModel.java --
   2    Copyright (C) 2002, 2004  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.table;
  40
  41 import java.beans.PropertyChangeEvent;
  42 import java.beans.PropertyChangeListener;
  43 import java.io.Serializable;
  44 import java.util.Enumeration;
  45 import java.util.EventListener;
  46 import java.util.Vector;
  47
  48 import javax.swing.DefaultListSelectionModel;
  49 import javax.swing.ListSelectionModel;
  50 import javax.swing.event.ChangeEvent;
  51 import javax.swing.event.EventListenerList;
  52 import javax.swing.event.ListSelectionEvent;
  53 import javax.swing.event.ListSelectionListener;
  54 import javax.swing.event.TableColumnModelEvent;
  55 import javax.swing.event.TableColumnModelListener;
  56
  57 /**
  58  * DefaultTableColumnModel
  59  * @author      Andrew Selkirk
  60  * @version     1.0
  61  */
  62 public class DefaultTableColumnModel
  63   implements TableColumnModel, PropertyChangeListener, ListSelectionListener,
  64              Serializable
  65 {
  66   private static final long serialVersionUID = 6580012493508960512L;
  67
  68   /**
  69    * Columns that this model keeps track of.
  70    */
  71   protected Vector tableColumns;
  72
  73   /**
  74    * Selection Model that keeps track of columns selection
  75    */
  76   protected ListSelectionModel selectionModel;
  77
  78   /**
  79    * Space between two columns. By default it is set to 1
  80    */
  81   protected int columnMargin;
  82
  83   /**
  84    * listenerList keeps track of all listeners registered with this model
  85    */
  86   protected EventListenerList listenerList = new EventListenerList();
  87
  88   /**
  89    * changeEvent is fired when change occurs in one of the columns properties
  90    */
  91   protected transient ChangeEvent changeEvent = new ChangeEvent(this);
  92
  93   /**
  94    * Indicates whether columns can be selected
  95    */
  96   protected boolean columnSelectionAllowed;
  97
  98   /**
  99    * Total width of all the columns in this model
 100    */
 101   protected int totalColumnWidth;
 102
 103   /**
 104    * Constructor DefaultTableColumnModel
 105    */
 106   public DefaultTableColumnModel()
 107   {
 108     tableColumns = new Vector();
 109     setSelectionModel(createSelectionModel());
 110     columnMargin = 1;
 111     columnSelectionAllowed = false;
 112   }
 113
 114   /**
 115    * addColumn adds column to the model. This method fires ColumnAdded
 116    * event to model's registered TableColumnModelListeners.
 117    *
 118    * @param col column to add
 119    */
 120   public void addColumn(TableColumn col)
 121   {
 122     tableColumns.add(col);
 123     invalidateWidthCache();
 124     fireColumnAdded(new TableColumnModelEvent(this,0,tableColumns.size()));
 125   }
 126
 127   /**
 128    * removeColumn removes table column from the model. This method fires
 129    * ColumnRemoved event to model's registered TableColumnModelListeners.
 130    *
 131    * @param col column to be removed
 132    */
 133   public void removeColumn(TableColumn col)
 134   {
 135     int index = getColumnIndex(col);
 136     fireColumnRemoved(new TableColumnModelEvent(this,index,0));
 137     tableColumns.remove(col);
 138     invalidateWidthCache();
 139   }
 140
 141   /**
 142    * moveColumn moves column at index i to index j. This method fires
 143    * ColumnMoved event to model's registered TableColumnModelListeners.
 144    *
 145    * @param i index of the column that will be moved
 146    * @param j index of column's new location
 147    */
 148   public void moveColumn(int i, int j)
 149   {
 150     Object tmp = tableColumns.get(i);
 151     tableColumns.set(i, tableColumns.get(j));
 152     tableColumns.set(j, tmp);
 153     fireColumnAdded(new TableColumnModelEvent(this,i,j));
 154   }
 155
 156   /**
 157    * setColumnMargin sets margin of the columns.
 158    * @param m new column margin
 159    */
 160   public void setColumnMargin(int m)
 161   {
 162     columnMargin = m;
 163     fireColumnMarginChanged();
 164   }
 165
 166   /**
 167    * getColumnCount returns number of columns in the model
 168    * @return int number of columns in the model
 169    */
 170   public int getColumnCount()
 171   {
 172     return tableColumns.size();
 173   }
 174
 175   /**
 176    * getColumns
 177    * @return Enumeration
 178    */
 179   public Enumeration getColumns()
 180   {
 181     return tableColumns.elements();
 182   }
 183
 184   /**
 185    * getColumnIndex returns index of the specified column
 186    *
 187    * @param identifier identifier of the column
 188    * @return int index of the given column
 189    */
 190   public int getColumnIndex(Object identifier)
 191   {
 192     return tableColumns.indexOf(identifier, 0);
 193   }
 194
 195   /**
 196    * getColumn returns column at the specified index
 197    * @param i index of the column
 198    * @return TableColumn column at the specified index
 199    */
 200   public TableColumn getColumn(int i)
 201   {
 202     return (TableColumn) tableColumns.get(i);
 203   }
 204
 205   /**
 206    * getColumnMargin returns column margin
 207    * @return int column margin
 208    */
 209   public int getColumnMargin()
 210   {
 211     return columnMargin;
 212   }
 213
 214   /**
 215    * getColumnIndexAtX returns column that contains specified x-coordinate.
 216    * @param x x-coordinate that column should contain
 217    * @return int index of the column that contains specified x-coordinate relative
 218    * to this column model
 219    */
 220   public int getColumnIndexAtX(int x)
 221   {
 222     for (int i = 0; i < tableColumns.size(); ++i)
 223       {
 224         int w = ((TableColumn)tableColumns.get(i)).getWidth();
 225         if (0 <= x && x < w)
 226           return i;
 227         else
 228           x -= w;
 229       }
 230     return -1;
 231   }
 232
 233   /**
 234    * getTotalColumnWidth returns total width of all the columns including
 235    * column's margins.
 236    *
 237    * @return total width of all the columns
 238    */
 239   public int getTotalColumnWidth()
 240   {
 241     if (totalColumnWidth == -1)
 242       recalcWidthCache();
 243     return totalColumnWidth;
 244   }
 245
 246   /**
 247    * setSelectionModel sets selection model that will be used by this ColumnTableModel
 248    * to keep track of currently selected columns
 249    *
 250    * @param model new selection model
 251    * @exception IllegalArgumentException if model is null
 252    */
 253   public void setSelectionModel(ListSelectionModel model)
 254   {
 255     if (model == null)
 256       throw new IllegalArgumentException();
 257
 258     selectionModel = model;
 259     selectionModel.addListSelectionListener(this);
 260   }
 261
 262   /**
 263    * getSelectionModel returns selection model
 264    * @return ListSelectionModel selection model
 265    */
 266   public ListSelectionModel getSelectionModel()
 267   {
 268     return selectionModel;
 269   }
 270
 271   /**
 272    * setColumnSelectionAllowed sets whether column selection is allowed
 273    * or not.
 274    *
 275    * @param flag true if column selection is allowed and false otherwise
 276    */
 277   public void setColumnSelectionAllowed(boolean flag)
 278   {
 279     columnSelectionAllowed = flag;
 280   }
 281
 282   /**
 283    * getColumnSelectionAllowed indicates whether column selection is
 284    * allowed or not.
 285    *
 286    * @return boolean true if column selection is allowed and false otherwise.
 287    */
 288   public boolean getColumnSelectionAllowed()
 289   {
 290     return columnSelectionAllowed;
 291   }
 292
 293   /**
 294    * getSelectedColumns returns array containing indexes of currently
 295    * selected columns
 296    *
 297    * @return int[] array containing indexes of currently selected columns
 298    */
 299   public int[] getSelectedColumns()
 300   {
 301     // FIXME: Implementation of this method was taken from private method
 302     // JTable.getSelections(), which is used in various places in JTable
 303     // including selected row calculations and cannot be simply removed.
 304     // This design should be improved to illuminate duplication of code.
 305
 306     ListSelectionModel lsm = this.selectionModel;
 307     int sz = getSelectedColumnCount();
 308     int [] ret = new int[sz];
 309
 310     int lo = lsm.getMinSelectionIndex();
 311     int hi = lsm.getMaxSelectionIndex();
 312     int j = 0;
 313     java.util.ArrayList ls = new java.util.ArrayList();
 314     if (lo != -1 && hi != -1)
 315       {
 316         switch (lsm.getSelectionMode())
 317           {
 318           case ListSelectionModel.SINGLE_SELECTION:
 319             ret[0] = lo;
 320             break;
 321
 322           case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
 323             for (int i = lo; i <= hi; ++i)
 324               ret[j++] = i;
 325             break;
 326
 327           case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
 328             for (int i = lo; i <= hi; ++i)
 329               if (lsm.isSelectedIndex(i))
 330                 ret[j++] = i;
 331             break;
 332           }
 333       }
 334     return ret;
 335   }
 336
 337   /**
 338    * getSelectedColumnCount returns number of currently selected columns
 339    * @return int number of currently selected columns
 340    */
 341   public int getSelectedColumnCount()
 342   {
 343     // FIXME: Implementation of this method was taken from private method
 344     // JTable.countSelections(), which is used in various places in JTable
 345     // including selected row calculations and cannot be simply removed.
 346     // This design should be improved to illuminate duplication of code.
 347
 348     ListSelectionModel lsm = this.selectionModel;
 349     int lo = lsm.getMinSelectionIndex();
 350     int hi = lsm.getMaxSelectionIndex();
 351     int sum = 0;
 352
 353     if (lo != -1 && hi != -1)
 354       {
 355         switch (lsm.getSelectionMode())
 356           {
 357           case ListSelectionModel.SINGLE_SELECTION:
 358             sum = 1;
 359             break;
 360
 361           case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
 362             sum = hi - lo + 1;
 363             break;
 364
 365           case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
 366             for (int i = lo; i <= hi; ++i)
 367               if (lsm.isSelectedIndex(i))
 368                 ++sum;
 369             break;
 370           }
 371       }
 372
 373      return sum;
 374   }
 375
 376   /**
 377    * addColumnModelListener adds specified listener to the model's
 378    * listener list
 379    *
 380    * @param listener the listener to add
 381    */
 382   public void addColumnModelListener(TableColumnModelListener listener)
 383   {
 384     listenerList.add(TableColumnModelListener.class, listener);
 385   }
 386
 387   /**
 388    * removeColumnModelListener removes specified listener from the model's
 389    * listener list.
 390    *
 391    * @param listener the listener to remove
 392    */
 393   public void removeColumnModelListener(TableColumnModelListener listener)
 394   {
 395     listenerList.remove(TableColumnModelListener.class, listener);
 396   }
 397
 398   /**
 399    * @since 1.4
 400    */
 401   public TableColumnModelListener[] getColumnModelListeners()
 402   {
 403     return (TableColumnModelListener[])
 404       listenerList.getListeners(TableColumnModelListener.class);
 405   }
 406
 407   /**
 408    * fireColumnAdded fires TableColumnModelEvent to registered
 409    * TableColumnModelListeners to indicate that column was added
 410    *
 411    * @param e TableColumnModelEvent
 412    */
 413   protected void fireColumnAdded(TableColumnModelEvent e)
 414   {
 415     TableColumnModelListener[] listeners = getColumnModelListeners();
 416
 417     for (int i=0; i< listeners.length; i++)
 418       listeners[i].columnAdded(e);
 419   }
 420
 421   /**
 422    * fireColumnAdded fires TableColumnModelEvent to registered
 423    * TableColumnModelListeners to indicate that column was removed
 424    *
 425    * @param e TableColumnModelEvent
 426    */
 427   protected void fireColumnRemoved(TableColumnModelEvent e)
 428   {
 429     TableColumnModelListener[] listeners = getColumnModelListeners();
 430
 431     for (int i=0; i< listeners.length; i++)
 432       listeners[i].columnRemoved(e);
 433   }
 434
 435   /**
 436    * fireColumnAdded fires TableColumnModelEvent to registered
 437    * TableColumnModelListeners to indicate that column was moved
 438    *
 439    * @param e TableColumnModelEvent
 440    */
 441   protected void fireColumnMoved(TableColumnModelEvent e)
 442   {
 443     TableColumnModelListener[] listeners = getColumnModelListeners();
 444
 445     for (int i=0; i< listeners.length; i++)
 446       listeners[i].columnMoved(e);
 447   }
 448
 449   /**
 450    * fireColumnSelectionChanged fires TableColumnModelEvent to model's
 451    * registered TableColumnModelListeners to indicate that different column
 452    * was selected.
 453    *
 454    * @param evt ListSelectionEvent
 455    */
 456   protected void fireColumnSelectionChanged(ListSelectionEvent evt)
 457   {
 458     EventListener [] listeners = getListeners(TableColumnModelListener.class);
 459     for (int i = 0; i < listeners.length; ++i)
 460       ((TableColumnModelListener)listeners[i]).columnSelectionChanged(evt);
 461   }
 462
 463   /**
 464    * fireColumnMarginChanged fires TableColumnModelEvent to model's
 465    * registered TableColumnModelListeners to indicate that column margin
 466    * was changed.
 467    */
 468   protected void fireColumnMarginChanged()
 469   {
 470     EventListener [] listeners = getListeners(TableColumnModelListener.class);
 471     for (int i = 0; i < listeners.length; ++i)
 472       ((TableColumnModelListener)listeners[i]).columnMarginChanged(changeEvent);
 473   }
 474
 475   /**
 476    * getListeners returns currently registered listeners with this model.
 477    * @param listenerType type of listeners to return
 478    *
 479    * @return EventListener[] array of model's listeners of the specified type
 480    */
 481   public EventListener[] getListeners(Class listenerType)
 482   {
 483     return listenerList.getListeners(listenerType);
 484   }
 485
 486   /**
 487    * propertyChange handles changes occuring in the properties of the
 488    * model's columns.
 489    *
 490    * @param evt PropertyChangeEvent
 491    */
 492   public void propertyChange(PropertyChangeEvent evt)
 493   {
 494     if (evt.getPropertyName().equals(TableColumn.COLUMN_WIDTH_PROPERTY))
 495         invalidateWidthCache();
 496   }
 497
 498   /**
 499    * valueChanged handles changes in the selectionModel.
 500    * @param e ListSelectionEvent
 501    */
 502   public void valueChanged(ListSelectionEvent e)
 503   {
 504     fireColumnSelectionChanged(e);
 505   }
 506
 507   /**
 508    * createSelectionModel creates selection model that will keep track
 509    * of currently selected column(s)
 510    *
 511    * @return ListSelectionModel selection model of the columns
 512    */
 513   protected ListSelectionModel createSelectionModel()
 514   {
 515     return new DefaultListSelectionModel();
 516   }
 517
 518   /**
 519    * recalcWidthCache calculates total width of the columns.
 520    * If the current cache of the total width is in invalidated state,
 521    * then width is recalculated. Otherwise nothing is done.
 522    */
 523   protected void recalcWidthCache()
 524   {
 525     if (totalColumnWidth == -1)
 526       {
 527         totalColumnWidth = 0;
 528         for (int i = 0; i < tableColumns.size(); ++i)
 529           {
 530             totalColumnWidth += ((TableColumn)tableColumns.get(i)).getWidth();
 531           }
 532       }
 533   }
 534
 535   /**
 536    * invalidateWidthCache
 537    */
 538   private void invalidateWidthCache()
 539   {
 540     totalColumnWidth = -1;
 541   }
 542 }