1 /*
2 * Copyright (c) 1997, 2005, 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™
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 public class DefaultTableColumnModel implements TableColumnModel,
56 PropertyChangeListener, ListSelectionListener, Serializable
57 {
58 //
59 // Instance Variables
60 //
61
62 /** Array of TableColumn objects in this model */
63 protected Vector<TableColumn> tableColumns;
64
65 /** Model for keeping track of column selections */
66 protected ListSelectionModel selectionModel;
67
68 /** Width margin between each column */
69 protected int columnMargin;
70
71 /** List of TableColumnModelListener */
72 protected EventListenerList listenerList = new EventListenerList();
73
74 /** Change event (only one needed) */
75 transient protected ChangeEvent changeEvent = null;
76
77 /** Column selection allowed in this column model */
78 protected boolean columnSelectionAllowed;
79
80 /** A local cache of the combined width of all columns */
81 protected int totalColumnWidth;
82
83 //
84 // Constructors
85 //
86 /**
87 * Creates a default table column model.
88 */
89 public DefaultTableColumnModel() {
90 super();
91
92 // Initialize local ivars to default
93 tableColumns = new Vector<TableColumn>();
94 setSelectionModel(createSelectionModel());
95 setColumnMargin(1);
96 invalidateWidthCache();
97 setColumnSelectionAllowed(false);
98 }
99
100 //
101 // Modifying the model
102 //
103
104 /**
105 * Appends <code>aColumn</code> to the end of the
106 * <code>tableColumns</code> array.
107 * This method also posts the <code>columnAdded</code>
108 * event to its listeners.
109 *
110 * @param aColumn the <code>TableColumn</code> to be added
111 * @exception IllegalArgumentException if <code>aColumn</code> is
112 * <code>null</code>
113 * @see #removeColumn
114 */
115 public void addColumn(TableColumn aColumn) {
116 if (aColumn == null) {
117 throw new IllegalArgumentException("Object is null");
118 }
119
120 tableColumns.addElement(aColumn);
121 aColumn.addPropertyChangeListener(this);
122 invalidateWidthCache();
123
124 // Post columnAdded event notification
125 fireColumnAdded(new TableColumnModelEvent(this, 0,
126 getColumnCount() - 1));
127 }
128
129 /**
130 * Deletes the <code>column</code> from the
131 * <code>tableColumns</code> array. This method will do nothing if
132 * <code>column</code> is not in the table's columns list.
133 * <code>tile</code> is called
134 * to resize both the header and table views.
135 * This method also posts a <code>columnRemoved</code>
136 * event to its listeners.
137 *
138 * @param column the <code>TableColumn</code> to be removed
139 * @see #addColumn
140 */
141 public void removeColumn(TableColumn column) {
142 int columnIndex = tableColumns.indexOf(column);
143
144 if (columnIndex != -1) {
145 // Adjust for the selection
146 if (selectionModel != null) {
147 selectionModel.removeIndexInterval(columnIndex,columnIndex);
148 }
149
150 column.removePropertyChangeListener(this);
151 tableColumns.removeElementAt(columnIndex);
152 invalidateWidthCache();
153
154 // Post columnAdded event notification. (JTable and JTableHeader
155 // listens so they can adjust size and redraw)
156 fireColumnRemoved(new TableColumnModelEvent(this,
157 columnIndex, 0));
158 }
159 }
160
161 /**
162 * Moves the column and heading at <code>columnIndex</code> to
163 * <code>newIndex</code>. The old column at <code>columnIndex</code>
164 * will now be found at <code>newIndex</code>. The column
165 * that used to be at <code>newIndex</code> is shifted
166 * left or right to make room. This will not move any columns if
167 * <code>columnIndex</code> equals <code>newIndex</code>. This method
168 * also posts a <code>columnMoved</code> event to its listeners.
169 *
170 * @param columnIndex the index of column to be moved
171 * @param newIndex new index to move the column
172 * @exception IllegalArgumentException if <code>column</code> or
173 * <code>newIndex</code>
174 * are not in the valid range
175 */
176 public void moveColumn(int columnIndex, int newIndex) {
177 if ((columnIndex < 0) || (columnIndex >= getColumnCount()) ||
178 (newIndex < 0) || (newIndex >= getColumnCount()))
179 throw new IllegalArgumentException("moveColumn() - Index out of range");
180
181 TableColumn aColumn;
182
183 // If the column has not yet moved far enough to change positions
184 // post the event anyway, the "draggedDistance" property of the
185 // tableHeader will say how far the column has been dragged.
186 // Here we are really trying to get the best out of an
187 // API that could do with some rethinking. We preserve backward
188 // compatibility by slightly bending the meaning of these methods.
189 if (columnIndex == newIndex) {
190 fireColumnMoved(new TableColumnModelEvent(this, columnIndex, newIndex));
191 return;
192 }
193 aColumn = tableColumns.elementAt(columnIndex);
194
195 tableColumns.removeElementAt(columnIndex);
196 boolean selected = selectionModel.isSelectedIndex(columnIndex);
197 selectionModel.removeIndexInterval(columnIndex,columnIndex);
198
199 tableColumns.insertElementAt(aColumn, newIndex);
200 selectionModel.insertIndexInterval(newIndex, 1, true);
201 if (selected) {
202 selectionModel.addSelectionInterval(newIndex, newIndex);
203 }
204 else {
205 selectionModel.removeSelectionInterval(newIndex, newIndex);
206 }
207
208 fireColumnMoved(new TableColumnModelEvent(this, columnIndex,
209 newIndex));
210 }
211
212 /**
213 * Sets the column margin to <code>newMargin</code>. This method
214 * also posts a <code>columnMarginChanged</code> event to its
215 * listeners.
216 *
217 * @param newMargin the new margin width, in pixels
218 * @see #getColumnMargin
219 * @see #getTotalColumnWidth
220 */
221 public void setColumnMargin(int newMargin) {
222 if (newMargin != columnMargin) {
223 columnMargin = newMargin;
224 // Post columnMarginChanged event notification.
225 fireColumnMarginChanged();
226 }
227 }
228
229 //
230 // Querying the model
231 //
232
233 /**
234 * Returns the number of columns in the <code>tableColumns</code> array.
235 *
236 * @return the number of columns in the <code>tableColumns</code> array
237 * @see #getColumns
238 */
239 public int getColumnCount() {
240 return tableColumns.size();
241 }
242
243 /**
244 * Returns an <code>Enumeration</code> of all the columns in the model.
245 * @return an <code>Enumeration</code> of the columns in the model
246 */
247 public Enumeration<TableColumn> getColumns() {
248 return tableColumns.elements();
249 }
250
251 /**
252 * Returns the index of the first column in the <code>tableColumns</code>
253 * array whose identifier is equal to <code>identifier</code>,
254 * when compared using <code>equals</code>.
255 *
256 * @param identifier the identifier object
257 * @return the index of the first column in the
258 * <code>tableColumns</code> array whose identifier
259 * is equal to <code>identifier</code>
260 * @exception IllegalArgumentException if <code>identifier</code>
261 * is <code>null</code>, or if no
262 * <code>TableColumn</code> has this
263 * <code>identifier</code>
264 * @see #getColumn
265 */
266 public int getColumnIndex(Object identifier) {
267 if (identifier == null) {
268 throw new IllegalArgumentException("Identifier is null");
269 }
270
271 Enumeration enumeration = getColumns();
272 TableColumn aColumn;
273 int index = 0;
274
275 while (enumeration.hasMoreElements()) {
276 aColumn = (TableColumn)enumeration.nextElement();
277 // Compare them this way in case the column's identifier is null.
278 if (identifier.equals(aColumn.getIdentifier()))
279 return index;
280 index++;
281 }
282 throw new IllegalArgumentException("Identifier not found");
283 }
284
285 /**
286 * Returns the <code>TableColumn</code> object for the column
287 * at <code>columnIndex</code>.
288 *
289 * @param columnIndex the index of the column desired
290 * @return the <code>TableColumn</code> object for the column
291 * at <code>columnIndex</code>
292 */
293 public TableColumn getColumn(int columnIndex) {
294 return tableColumns.elementAt(columnIndex);
295 }
296
297 /**
298 * Returns the width margin for <code>TableColumn</code>.
299 * The default <code>columnMargin</code> is 1.
300 *
301 * @return the maximum width for the <code>TableColumn</code>
302 * @see #setColumnMargin
303 */
304 public int getColumnMargin() {
305 return columnMargin;
306 }
307
308 /**
309 * Returns the index of the column that lies at position <code>x</code>,
310 * or -1 if no column covers this point.
311 *
312 * In keeping with Swing's separable model architecture, a
313 * TableColumnModel does not know how the table columns actually appear on
314 * screen. The visual presentation of the columns is the responsibility
315 * of the view/controller object using this model (typically JTable). The
316 * view/controller need not display the columns sequentially from left to
317 * right. For example, columns could be displayed from right to left to
318 * accommodate a locale preference or some columns might be hidden at the
319 * request of the user. Because the model does not know how the columns
320 * are laid out on screen, the given <code>xPosition</code> should not be
321 * considered to be a coordinate in 2D graphics space. Instead, it should
322 * be considered to be a width from the start of the first column in the
323 * model. If the column index for a given X coordinate in 2D space is
324 * required, <code>JTable.columnAtPoint</code> can be used instead.
325 *
326 * @param x the horizontal location of interest
327 * @return the index of the column or -1 if no column is found
328 * @see javax.swing.JTable#columnAtPoint
329 */
330 public int getColumnIndexAtX(int x) {
331 if (x < 0) {
332 return -1;
333 }
334 int cc = getColumnCount();
335 for(int column = 0; column < cc; column++) {
336 x = x - getColumn(column).getWidth();
337 if (x < 0) {
338 return column;
339 }
340 }
341 return -1;
342 }
343
344 /**
345 * Returns the total combined width of all columns.
346 * @return the <code>totalColumnWidth</code> property
347 */
348 public int getTotalColumnWidth() {
349 if (totalColumnWidth == -1) {
350 recalcWidthCache();
351 }
352 return totalColumnWidth;
353 }
354
355 //
356 // Selection model
357 //
358
359 /**
360 * Sets the selection model for this <code>TableColumnModel</code>
361 * to <code>newModel</code>
362 * and registers for listener notifications from the new selection
363 * model. If <code>newModel</code> is <code>null</code>,
364 * an exception is thrown.
365 *
366 * @param newModel the new selection model
367 * @exception IllegalArgumentException if <code>newModel</code>
368 * is <code>null</code>
369 * @see #getSelectionModel
370 */
371 public void setSelectionModel(ListSelectionModel newModel) {
372 if (newModel == null) {
373 throw new IllegalArgumentException("Cannot set a null SelectionModel");
374 }
375
376 ListSelectionModel oldModel = selectionModel;
377
378 if (newModel != oldModel) {
379 if (oldModel != null) {
380 oldModel.removeListSelectionListener(this);
381 }
382
383 selectionModel= newModel;
384 newModel.addListSelectionListener(this);
385 }
386 }
387
388 /**
389 * Returns the <code>ListSelectionModel</code> that is used to
390 * maintain column selection state.
391 *
392 * @return the object that provides column selection state. Or
393 * <code>null</code> if row selection is not allowed.
394 * @see #setSelectionModel
395 */
396 public ListSelectionModel getSelectionModel() {
397 return selectionModel;
398 }
399
400 // implements javax.swing.table.TableColumnModel
401 /**
402 * Sets whether column selection is allowed. The default is false.
403 * @param flag true if column selection will be allowed, false otherwise
404 */
405 public void setColumnSelectionAllowed(boolean flag) {
406 columnSelectionAllowed = flag;
407 }
408
409 // implements javax.swing.table.TableColumnModel
410 /**
411 * Returns true if column selection is allowed, otherwise false.
412 * The default is false.
413 * @return the <code>columnSelectionAllowed</code> property
414 */
415 public boolean getColumnSelectionAllowed() {
416 return columnSelectionAllowed;
417 }
418
419 // implements javax.swing.table.TableColumnModel
420 /**
421 * Returns an array of selected columns. If <code>selectionModel</code>
422 * is <code>null</code>, returns an empty array.
423 * @return an array of selected columns or an empty array if nothing
424 * is selected or the <code>selectionModel</code> is
425 * <code>null</code>
426 */
427 public int[] getSelectedColumns() {
428 if (selectionModel != null) {
429 int iMin = selectionModel.getMinSelectionIndex();
430 int iMax = selectionModel.getMaxSelectionIndex();
431
432 if ((iMin == -1) || (iMax == -1)) {
433 return new int[0];
434 }
435
436 int[] rvTmp = new int[1+ (iMax - iMin)];
437 int n = 0;
438 for(int i = iMin; i <= iMax; i++) {
439 if (selectionModel.isSelectedIndex(i)) {
440 rvTmp[n++] = i;
441 }
442 }
443 int[] rv = new int[n];
444 System.arraycopy(rvTmp, 0, rv, 0, n);
445 return rv;
446 }
447 return new int[0];
448 }
449
450 // implements javax.swing.table.TableColumnModel
451 /**
452 * Returns the number of columns selected.
453 * @return the number of columns selected
454 */
455 public int getSelectedColumnCount() {
456 if (selectionModel != null) {
457 int iMin = selectionModel.getMinSelectionIndex();
458 int iMax = selectionModel.getMaxSelectionIndex();
459 int count = 0;
460
461 for(int i = iMin; i <= iMax; i++) {
462 if (selectionModel.isSelectedIndex(i)) {
463 count++;
464 }
465 }
466 return count;
467 }
468 return 0;
469 }
470
471 //
472 // Listener Support Methods
473 //
474
475 // implements javax.swing.table.TableColumnModel
476 /**
477 * Adds a listener for table column model events.
478 * @param x a <code>TableColumnModelListener</code> object
479 */
480 public void addColumnModelListener(TableColumnModelListener x) {
481 listenerList.add(TableColumnModelListener.class, x);
482 }
483
484 // implements javax.swing.table.TableColumnModel
485 /**
486 * Removes a listener for table column model events.
487 * @param x a <code>TableColumnModelListener</code> object
488 */
489 public void removeColumnModelListener(TableColumnModelListener x) {
490 listenerList.remove(TableColumnModelListener.class, x);
491 }
492
493 /**
494 * Returns an array of all the column model listeners
495 * registered on this model.
496 *
497 * @return all of this default table column model's <code>ColumnModelListener</code>s
498 * or an empty
499 * array if no column model listeners are currently registered
500 *
501 * @see #addColumnModelListener
502 * @see #removeColumnModelListener
503 *
504 * @since 1.4
505 */
506 public TableColumnModelListener[] getColumnModelListeners() {
507 return listenerList.getListeners(TableColumnModelListener.class);
508 }
509
510 //
511 // Event firing methods
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 fireColumnAdded(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 columnAdded(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 fireColumnRemoved(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 columnRemoved(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 fireColumnMoved(TableColumnModelEvent 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 columnMoved(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 * @param e the event received
592 * @see EventListenerList
593 */
594 protected void fireColumnSelectionChanged(ListSelectionEvent e) {
595 // Guaranteed to return a non-null array
596 Object[] listeners = listenerList.getListenerList();
597 // Process the listeners last to first, notifying
598 // those that are interested in this event
599 for (int i = listeners.length-2; i>=0; i-=2) {
600 if (listeners[i]==TableColumnModelListener.class) {
601 // Lazily create the event:
602 // if (e == null)
603 // e = new ChangeEvent(this);
604 ((TableColumnModelListener)listeners[i+1]).
605 columnSelectionChanged(e);
606 }
607 }
608 }
609
610 /**
611 * Notifies all listeners that have registered interest for
612 * notification on this event type. The event instance
613 * is lazily created using the parameters passed into
614 * the fire method.
615 * @see EventListenerList
616 */
617 protected void fireColumnMarginChanged() {
618 // Guaranteed to return a non-null array
619 Object[] listeners = listenerList.getListenerList();
620 // Process the listeners last to first, notifying
621 // those that are interested in this event
622 for (int i = listeners.length-2; i>=0; i-=2) {
623 if (listeners[i]==TableColumnModelListener.class) {
624 // Lazily create the event:
625 if (changeEvent == null)
626 changeEvent = new ChangeEvent(this);
627 ((TableColumnModelListener)listeners[i+1]).
628 columnMarginChanged(changeEvent);
629 }
630 }
631 }
632
633 /**
634 * Returns an array of all the objects currently registered
635 * as <code><em>Foo</em>Listener</code>s
636 * upon this model.
637 * <code><em>Foo</em>Listener</code>s are registered using the
638 * <code>add<em>Foo</em>Listener</code> method.
639 *
640 * <p>
641 *
642 * You can specify the <code>listenerType</code> argument
643 * with a class literal,
644 * such as
645 * <code><em>Foo</em>Listener.class</code>.
646 * For example, you can query a
647 * <code>DefaultTableColumnModel</code> <code>m</code>
648 * for its column model listeners with the following code:
649 *
650 * <pre>ColumnModelListener[] cmls = (ColumnModelListener[])(m.getListeners(ColumnModelListener.class));</pre>
651 *
652 * If no such listeners exist, this method returns an empty array.
653 *
654 * @param listenerType the type of listeners requested; this parameter
655 * should specify an interface that descends from
656 * <code>java.util.EventListener</code>
657 * @return an array of all objects registered as
658 * <code><em>Foo</em>Listener</code>s on this model,
659 * or an empty array if no such
660 * listeners have been added
661 * @exception ClassCastException if <code>listenerType</code>
662 * doesn't specify a class or interface that implements
663 * <code>java.util.EventListener</code>
664 *
665 * @see #getColumnModelListeners
666 * @since 1.3
667 */
668 public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
669 return listenerList.getListeners(listenerType);
670 }
671
672 //
673 // Implementing the PropertyChangeListener interface
674 //
675
676 // PENDING(alan)
677 // implements java.beans.PropertyChangeListener
678 /**
679 * Property Change Listener change method. Used to track changes
680 * to the column width or preferred column width.
681 *
682 * @param evt <code>PropertyChangeEvent</code>
683 */
684 public void propertyChange(PropertyChangeEvent evt) {
685 String name = evt.getPropertyName();
686
687 if (name == "width" || name == "preferredWidth") {
688 invalidateWidthCache();
689 // This is a misnomer, we're using this method
690 // simply to cause a relayout.
691 fireColumnMarginChanged();
692 }
693
694 }
695
696 //
697 // Implementing ListSelectionListener interface
698 //
699
700 // implements javax.swing.event.ListSelectionListener
701 /**
702 * A <code>ListSelectionListener</code> that forwards
703 * <code>ListSelectionEvents</code> when there is a column
704 * selection change.
705 *
706 * @param e the change event
707 */
708 public void valueChanged(ListSelectionEvent e) {
709 fireColumnSelectionChanged(e);
710 }
711
712 //
713 // Protected Methods
714 //
715
716 /**
717 * Creates a new default list selection model.
718 */
719 protected ListSelectionModel createSelectionModel() {
720 return new DefaultListSelectionModel();
721 }
722
723 /**
724 * Recalculates the total combined width of all columns. Updates the
725 * <code>totalColumnWidth</code> property.
726 */
727 protected void recalcWidthCache() {
728 Enumeration enumeration = getColumns();
729 totalColumnWidth = 0;
730 while (enumeration.hasMoreElements()) {
731 totalColumnWidth += ((TableColumn)enumeration.nextElement()).getWidth();
732 }
733 }
734
735 private void invalidateWidthCache() {
736 totalColumnWidth = -1;
737 }
738
739 } // End of class DefaultTableColumnModel