Source for javax.swing.JTable

   1: /* JTable.java -- 
   2:    Copyright (C) 2002, 2004, 2005, 2006  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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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;
  40: 
  41: import java.awt.Color;
  42: import java.awt.Component;
  43: import java.awt.Cursor;
  44: import java.awt.Dimension;
  45: import java.awt.Font;
  46: import java.awt.FontMetrics;
  47: import java.awt.Point;
  48: import java.awt.Rectangle;
  49: import java.awt.event.FocusListener;
  50: import java.beans.PropertyChangeEvent;
  51: import java.beans.PropertyChangeListener;
  52: import java.text.DateFormat;
  53: import java.text.NumberFormat;
  54: import java.util.Date;
  55: import java.util.EventObject;
  56: import java.util.Hashtable;
  57: import java.util.Locale;
  58: import java.util.Vector;
  59: 
  60: import javax.accessibility.Accessible;
  61: import javax.accessibility.AccessibleComponent;
  62: import javax.accessibility.AccessibleContext;
  63: import javax.accessibility.AccessibleExtendedTable;
  64: import javax.accessibility.AccessibleRole;
  65: import javax.accessibility.AccessibleSelection;
  66: import javax.accessibility.AccessibleState;
  67: import javax.accessibility.AccessibleStateSet;
  68: import javax.accessibility.AccessibleTable;
  69: import javax.accessibility.AccessibleTableModelChange;
  70: import javax.swing.event.CellEditorListener;
  71: import javax.swing.event.ChangeEvent;
  72: import javax.swing.event.ListSelectionEvent;
  73: import javax.swing.event.ListSelectionListener;
  74: import javax.swing.event.TableColumnModelEvent;
  75: import javax.swing.event.TableColumnModelListener;
  76: import javax.swing.event.TableModelEvent;
  77: import javax.swing.event.TableModelListener;
  78: import javax.swing.plaf.TableUI;
  79: import javax.swing.table.DefaultTableCellRenderer;
  80: import javax.swing.table.DefaultTableColumnModel;
  81: import javax.swing.table.DefaultTableModel;
  82: import javax.swing.table.JTableHeader;
  83: import javax.swing.table.TableCellEditor;
  84: import javax.swing.table.TableCellRenderer;
  85: import javax.swing.table.TableColumn;
  86: import javax.swing.table.TableColumnModel;
  87: import javax.swing.table.TableModel;
  88: 
  89: /**
  90:  * The table component, displaying information, organized in rows and columns.
  91:  * The table can be placed in the scroll bar and have the optional header
  92:  * that is always visible. Cell values may be editable after double clicking
  93:  * on the cell. Cell columns may have various data types, that are 
  94:  * displayed and edited by the different renderers and editors. It is possible
  95:  * to set different column width. The columns are also resizeable by 
  96:  * dragging the column boundary in the header.
  97:  */
  98: public class JTable
  99:   extends JComponent
 100:   implements TableModelListener, Scrollable, TableColumnModelListener,
 101:              ListSelectionListener, CellEditorListener, Accessible
 102: {
 103:   /**
 104:    * Provides accessibility support for <code>JTable</code>.
 105:    *
 106:    * @author Roman Kennke (kennke@aicas.com)
 107:    */
 108:   protected class AccessibleJTable
 109:     extends AccessibleJComponent
 110:     implements AccessibleSelection, ListSelectionListener, TableModelListener,
 111:     TableColumnModelListener, CellEditorListener, PropertyChangeListener,
 112:     AccessibleExtendedTable
 113:   {
 114: 
 115:     /**
 116:      * Provides accessibility support for table cells.
 117:      *
 118:      * @author Roman Kennke (kennke@aicas.com)
 119:      */
 120:     protected class AccessibleJTableCell
 121:       extends AccessibleContext
 122:       implements Accessible, AccessibleComponent
 123:     {
 124: 
 125:       /**
 126:        * The table of this cell.
 127:        */
 128:       private JTable table;
 129: 
 130:       /**
 131:        * The row index of this cell.
 132:        */
 133:       private int row;
 134: 
 135:       /**
 136:        * The column index of this cell.
 137:        */
 138:       private int column;
 139: 
 140:       /**
 141:        * The index of this cell inside the AccessibleJTable parent.
 142:        */
 143:       private int index;
 144: 
 145:       /**
 146:        * Creates a new <code>AccessibleJTableCell</code>.
 147:        *
 148:        * @param t the table
 149:        * @param r the row
 150:        * @param c the column
 151:        * @param i the index of this cell inside the accessible table parent
 152:        */
 153:       public AccessibleJTableCell(JTable t, int r, int c, int i)
 154:       {
 155:         table = t;
 156:         row = r;
 157:         column = c;
 158:         index = i;
 159:       }
 160: 
 161:       /**
 162:        * Returns the accessible row for the table cell.
 163:        *
 164:        * @return the accessible row for the table cell
 165:        */
 166:       public AccessibleRole getAccessibleRole()
 167:       {
 168:         // TODO: What is the role of the table cell?
 169:         // Seems like the RI returns UNKNOWN here for 'normal' cells, might
 170:         // be different for special renderers though (not tested yet).
 171:         return AccessibleRole.UNKNOWN;
 172:       }
 173: 
 174:       /**
 175:        * Returns the accessible state set of this accessible table cell.
 176:        *
 177:        * @return the accessible state set of this accessible table cell
 178:        */
 179:       public AccessibleStateSet getAccessibleStateSet()
 180:       {
 181:         AccessibleStateSet state = new AccessibleStateSet();
 182: 
 183:         // Figure out the SHOWING state.
 184:         Rectangle visibleRect = getVisibleRect();
 185:         Rectangle cellRect = getCellRect(row, column, false);
 186:         if (visibleRect.intersects(cellRect))
 187:           state.add(AccessibleState.SHOWING);
 188: 
 189:         // Figure out SELECTED state.
 190:         if (isCellSelected(row, column))
 191:           state.add(AccessibleState.SELECTED);
 192: 
 193:         // Figure out ACTIVE state.
 194:         if (row == getSelectedRow() && column == getSelectedColumn())
 195:           state.add(AccessibleState.ACTIVE);
 196: 
 197:         // TRANSIENT seems to be always set in the RI.
 198:         state.add(AccessibleState.TRANSIENT);
 199: 
 200:         // TODO: Any other state to handle here?
 201:         return state;
 202:       }
 203: 
 204:       /**
 205:        * Returns the index of this cell in the parent object.
 206:        *
 207:        * @return the index of this cell in the parent object
 208:        */
 209:       public int getAccessibleIndexInParent()
 210:       {
 211:         return index;
 212:       }
 213: 
 214:       /**
 215:        * Returns the number of children of this object. Table cells cannot have
 216:        * children, so we return <code>0</code> here.
 217:        *
 218:        * @return <code>0</code>
 219:        */
 220:       public int getAccessibleChildrenCount()
 221:       {
 222:         return 0;
 223:       }
 224: 
 225:       /**
 226:        * Returns the accessible child at index <code>i</code>. Table cells
 227:        * don't have children, so we return <code>null</code> here.
 228:        *
 229:        * @return <code>null</code>
 230:        */
 231:       public Accessible getAccessibleChild(int i)
 232:       {
 233:         return null;
 234:       }
 235: 
 236:       /**
 237:        * Returns the locale setting for this accessible table cell.
 238:        *
 239:        * @return the locale setting for this accessible table cell
 240:        */
 241:       public Locale getLocale()
 242:       {
 243:         // TODO: For now, we return english here. This must be fixed as soon
 244:         // as we have a localized Swing.
 245:         return Locale.ENGLISH;
 246:       }
 247: 
 248:       /**
 249:        * Returns the accessible context of this table cell. Since accessible
 250:        * table cells are their own accessible context, we return
 251:        * <code>this</code>.
 252:        *
 253:        * @return the accessible context of this table cell
 254:        */
 255:       public AccessibleContext getAccessibleContext()
 256:       {
 257:         return this;
 258:       }
 259: 
 260:       /**
 261:        * Returns the background color of this cell.
 262:        *
 263:        * @return the background color of this cell
 264:        */
 265:       public Color getBackground()
 266:       {
 267:         return table.getBackground();
 268:       }
 269: 
 270:       /**
 271:        * Sets the background of the cell. Since table cells cannot have
 272:        * individual background colors, this method does nothing. Set the
 273:        * background directly on the table instead.
 274:        * 
 275:        * @param color not used
 276:        */
 277:       public void setBackground(Color color)
 278:       {
 279:         // This method does nothing. See API comments.
 280:       }
 281: 
 282:       /**
 283:        * Returns the foreground color of the table cell.
 284:        *
 285:        * @return the foreground color of the table cell
 286:        */
 287:       public Color getForeground()
 288:       {
 289:         return table.getForeground();
 290:       }
 291: 
 292:       /**
 293:        * Sets the foreground of the cell. Since table cells cannot have
 294:        * individual foreground colors, this method does nothing. Set the
 295:        * foreground directly on the table instead.
 296:        * 
 297:        * @param color not used
 298:        */
 299:       public void setForeground(Color color)
 300:       {
 301:         // This method does nothing. See API comments.
 302:       }
 303: 
 304:       /**
 305:        * Returns the cursor for this table cell.
 306:        *
 307:        * @return the cursor for this table cell
 308:        */
 309:       public Cursor getCursor()
 310:       {
 311:         return table.getCursor();
 312:       }
 313: 
 314:       /**
 315:        * Sets the cursor of the cell. Since table cells cannot have
 316:        * individual cursors, this method does nothing. Set the
 317:        * cursor directly on the table instead.
 318:        * 
 319:        * @param cursor not used
 320:        */
 321:       public void setCursor(Cursor cursor)
 322:       {
 323:         // This method does nothing. See API comments.
 324:       }
 325: 
 326:       /**
 327:        * Returns the font of the table cell.
 328:        *
 329:        * @return the font of the table cell
 330:        */
 331:       public Font getFont()
 332:       {
 333:         return table.getFont();
 334:       }
 335: 
 336:       /**
 337:        * Sets the font of the cell. Since table cells cannot have
 338:        * individual fonts, this method does nothing. Set the
 339:        * font directly on the table instead.
 340:        * 
 341:        * @param font not used
 342:        */
 343:       public void setFont(Font font)
 344:       {
 345:         // This method does nothing. See API comments.
 346:       }
 347: 
 348:       /**
 349:        * Returns the font metrics for a specified font.
 350:        *
 351:        * @param font the font for which we return the metrics
 352:        *
 353:        * @return the font metrics for a specified font
 354:        */
 355:       public FontMetrics getFontMetrics(Font font)
 356:       {
 357:         return table.getFontMetrics(font);
 358:       }
 359: 
 360:       /**
 361:        * Returns <code>true</code> if this table cell is enabled,
 362:        * <code>false</code> otherwise.
 363:        *
 364:        * @return <code>true</code> if this table cell is enabled,
 365:        *         <code>false</code> otherwise
 366:        */
 367:       public boolean isEnabled()
 368:       {
 369:         return table.isEnabled();
 370:       }
 371: 
 372:       /**
 373:        * Table cells cannot be disabled or enabled individually, so this method
 374:        * does nothing. Set the enabled flag on the table itself.
 375:        *
 376:        * @param b not used here
 377:        */
 378:       public void setEnabled(boolean b)
 379:       {
 380:         // This method does nothing. See API comments.
 381:       }
 382: 
 383:       /**
 384:        * Returns <code>true</code> if this cell is visible, <code>false</code>
 385:        * otherwise.
 386:        *
 387:        * @return <code>true</code> if this cell is visible, <code>false</code>
 388:        *         otherwise
 389:        */
 390:       public boolean isVisible()
 391:       {
 392:         return table.isVisible();
 393:       }
 394: 
 395:       /**
 396:        * The visibility cannot be set on individual table cells, so this method
 397:        * does nothing. Set the visibility on the table itself.
 398:        *
 399:        * @param b not used
 400:        */
 401:       public void setVisible(boolean b)
 402:       {
 403:         // This method does nothing. See API comments.
 404:       }
 405: 
 406:       /**
 407:        * Returns <code>true</code> if this table cell is currently showing on
 408:        * screen.
 409:        *
 410:        * @return <code>true</code> if this table cell is currently showing on
 411:        *         screen
 412:        */
 413:       public boolean isShowing()
 414:       {
 415:         return table.isShowing();
 416:       }
 417: 
 418:       /**
 419:        * Returns <code>true</code> if this table cell contains the location
 420:        * at <code>point</code>, <code>false</code> otherwise.
 421:        * <code>point</code> is interpreted as relative to the coordinate system
 422:        * of the table cell.
 423:        *
 424:        * @return <code>true</code> if this table cell contains the location
 425:        *         at <code>point</code>, <code>false</code> otherwise
 426:        */
 427:       public boolean contains(Point point)
 428:       {
 429:         Rectangle cellRect = table.getCellRect(row, column, true);
 430:         cellRect.x = 0;
 431:         cellRect.y = 0;
 432:         return cellRect.contains(point);
 433:       }
 434: 
 435:       /**
 436:        * Returns the screen location of the table cell.
 437:        *
 438:        * @return the screen location of the table cell
 439:        */
 440:       public Point getLocationOnScreen()
 441:       {
 442:         Point tableLoc = table.getLocationOnScreen();
 443:         Rectangle cellRect = table.getCellRect(row, column, true);
 444:         tableLoc.x += cellRect.x;
 445:         tableLoc.y += cellRect.y;
 446:         return tableLoc;
 447:       }
 448: 
 449:       /**
 450:        * Returns the location of this cell relative to the table's bounds.
 451:        *
 452:        * @return the location of this cell relative to the table's bounds
 453:        */
 454:       public Point getLocation()
 455:       {
 456:         Rectangle cellRect = table.getCellRect(row, column, true);
 457:         return new Point(cellRect.x, cellRect.y);
 458:       }
 459: 
 460:       /**
 461:        * The location of the table cells cannot be manipulated directly, so
 462:        * this method does nothing.
 463:        *
 464:        * @param point not used
 465:        */
 466:       public void setLocation(Point point)
 467:       {
 468:         // This method does nothing. See API comments.
 469:       }
 470: 
 471:       /**
 472:        * Returns the bounds of the cell relative to its table.
 473:        *
 474:        * @return the bounds of the cell relative to its table
 475:        */
 476:       public Rectangle getBounds()
 477:       {
 478:         return table.getCellRect(row, column, true);
 479:       }
 480: 
 481:       /**
 482:        * The bounds of the table cells cannot be manipulated directly, so
 483:        * this method does nothing.
 484:        *
 485:        * @param rectangle not used
 486:        */
 487:       public void setBounds(Rectangle rectangle)
 488:       {
 489:         // This method does nothing. See API comments.
 490:       }
 491: 
 492:       /**
 493:        * Returns the size of the table cell.
 494:        *
 495:        * @return the size of the table cell
 496:        */
 497:       public Dimension getSize()
 498:       {
 499:         Rectangle cellRect = table.getCellRect(row, column, true);
 500:         return new Dimension(cellRect.width, cellRect.height);
 501:       }
 502: 
 503:       /**
 504:        * The size cannot be set on table cells directly, so this method does
 505:        * nothing.
 506:        *
 507:        * @param dimension not used
 508:        */
 509:       public void setSize(Dimension dimension)
 510:       {
 511:         // This method does nothing. See API comments.
 512:       }
 513: 
 514:       /**
 515:        * Table cells have no children, so we return <code>null</code> here.
 516:        *
 517:        * @return <code>null</code>
 518:        */
 519:       public Accessible getAccessibleAt(Point point)
 520:       {
 521:         return null;
 522:       }
 523: 
 524:       /**
 525:        * Returns <code>true</code> if this table cell is focus traversable,
 526:        * <code>false</code> otherwise.
 527:        *
 528:        * @return <code>true</code> if this table cell is focus traversable,
 529:        *         <code>false</code> otherwise
 530:        */
 531:       public boolean isFocusTraversable()
 532:       {
 533:         return table.isFocusable();
 534:       }
 535: 
 536:       /**
 537:        * Requests that this table cell gets the keyboard focus.
 538:        */
 539:       public void requestFocus()
 540:       {
 541:         // We first set the selection models' lead selection to this cell.
 542:         table.getColumnModel().getSelectionModel()
 543:         .setLeadSelectionIndex(column);
 544:         table.getSelectionModel().setLeadSelectionIndex(row);
 545:         // Now we request that the table receives focus.
 546:         table.requestFocus();
 547:       }
 548: 
 549:       /**
 550:        * Adds a focus listener to this cell. The focus listener is really
 551:        * added to the table, so there is no way to find out when an individual
 552:        * cell changes the focus.
 553:        *
 554:        * @param listener the focus listener to add
 555:        */
 556:       public void addFocusListener(FocusListener listener)
 557:       {
 558:         table.addFocusListener(listener);
 559:       }
 560: 
 561:       /**
 562:        * Removes a focus listener from the cell. The focus listener is really
 563:        * removed from the table.
 564:        *
 565:        * @param listener the listener to remove
 566:        */
 567:       public void removeFocusListener(FocusListener listener)
 568:       {
 569:         table.removeFocusListener(listener);
 570:       }
 571:         
 572:     }
 573: 
 574:     protected class AccessibleJTableModelChange
 575:       implements AccessibleTableModelChange
 576:     {
 577:       protected int type;
 578:       protected int firstRow;
 579:       protected int lastRow;
 580:       protected int firstColumn;
 581:       protected int lastColumn;
 582: 
 583:       protected AccessibleJTableModelChange(int type, int firstRow,
 584:                                             int lastRow, int firstColumn,
 585:                                             int lastColumn)
 586:       {
 587:         this.type = type;
 588:         this.firstRow = firstRow;
 589:         this.lastRow = lastRow;
 590:         this.firstColumn = firstColumn;
 591:         this.lastColumn = lastColumn;
 592:       }
 593: 
 594:       public int getType()
 595:       {
 596:         return type;
 597:       }
 598: 
 599:       public int getFirstRow()
 600:       {
 601:         return firstRow;
 602:       }
 603: 
 604:       public int getLastRow()
 605:       {
 606:         return lastRow;
 607:       }
 608: 
 609:       public int getFirstColumn()
 610:       {
 611:         return firstColumn;
 612:       }
 613: 
 614:       public int getLastColumn()
 615:       {
 616:         return lastColumn;
 617:       }
 618:     }
 619: 
 620:     /**
 621:      * The RI returns an instance with this name in
 622:      * {@link #getAccessibleColumnHeader()}, this makes sense, so we do the
 623:      * same.
 624:      */
 625:     private class AccessibleTableHeader
 626:       implements AccessibleTable
 627:     {
 628: 
 629:       /**
 630:        * The JTableHeader wrapped by this class.
 631:        */
 632:       private JTableHeader header;
 633: 
 634:       /**
 635:        * Creates a new instance.
 636:        *
 637:        * @param h the JTableHeader to wrap
 638:        */
 639:       private AccessibleTableHeader(JTableHeader h)
 640:       {
 641:         header = h;
 642:       }
 643: 
 644:       /**
 645:        * Returns the caption for the table header.
 646:        *
 647:        * @return the caption for the table header
 648:        */
 649:       public Accessible getAccessibleCaption()
 650:       {
 651:         // The RI seems to always return null here, so do we.
 652:         return null;
 653:       }
 654: 
 655:       /**
 656:        * Sets the caption for the table header.
 657:        *
 658:        * @param caption the caption to set
 659:        */
 660:       public void setAccessibleCaption(Accessible caption)
 661:       {
 662:         // This seems to be a no-op in the RI, so we do the same.
 663:       }
 664: 
 665:       /**
 666:        * Returns the caption for the table header.
 667:        *
 668:        * @return the caption for the table header
 669:        */
 670:       public Accessible getAccessibleSummary()
 671:       {
 672:         // The RI seems to always return null here, so do we.
 673:         return null;
 674:       }
 675: 
 676:       /**
 677:        * Sets the summary for the table header.
 678:        *
 679:        * @param summary the caption to set
 680:        */
 681:       public void setAccessibleSummary(Accessible summary)
 682:       {
 683:         // This seems to be a no-op in the RI, so we do the same.
 684:       }
 685: 
 686:       /**
 687:        * Returns the number of rows, which is always 1 for the table header.
 688:        *
 689:        * @return the number of rows
 690:        */
 691:       public int getAccessibleRowCount()
 692:       {
 693:         return 1;
 694:       }
 695: 
 696:       /**
 697:        * Returns the number of columns in the table header.
 698:        *
 699:        * @return the number of columns in the table header
 700:        */
 701:       public int getAccessibleColumnCount()
 702:       {
 703:         return header.getColumnModel().getColumnCount();
 704:       }
 705: 
 706:       /**
 707:        * Returns the accessible child at the specified row and column.
 708:        * The row number is ignored here, and we return an
 709:        * AccessibleJTableHeaderCell here with the renderer component as
 710:        * component.
 711:        *
 712:        * @param r the row number
 713:        * @param c the column number
 714:        *
 715:        * @return the accessible child at the specified row and column
 716:        */
 717:       public Accessible getAccessibleAt(int r, int c)
 718:       {
 719:         TableColumn column = header.getColumnModel().getColumn(c);
 720:         TableCellRenderer rend = column.getHeaderRenderer();
 721:         if (rend == null)
 722:           rend = header.getDefaultRenderer();
 723:         Component comp =
 724:           rend.getTableCellRendererComponent(header.getTable(),
 725:                                              column.getHeaderValue(), false,
 726:                                              false, -1, c);
 727:         return new AccessibleJTableHeaderCell(header, comp, r, c);
 728:       }
 729: 
 730:       public int getAccessibleRowExtentAt(int r, int c)
 731:       {
 732:         // TODO Auto-generated method stub
 733:         return 0;
 734:       }
 735: 
 736:       public int getAccessibleColumnExtentAt(int r, int c)
 737:       {
 738:         // TODO Auto-generated method stub
 739:         return 0;
 740:       }
 741: 
 742:       public AccessibleTable getAccessibleRowHeader()
 743:       {
 744:         // TODO Auto-generated method stub
 745:         return null;
 746:       }
 747: 
 748:       public void setAccessibleRowHeader(AccessibleTable header)
 749:       {
 750:         // TODO Auto-generated method stub
 751:         
 752:       }
 753: 
 754:       public AccessibleTable getAccessibleColumnHeader()
 755:       {
 756:         // TODO Auto-generated method stub
 757:         return null;
 758:       }
 759: 
 760:       public void setAccessibleColumnHeader(AccessibleTable header)
 761:       {
 762:         // TODO Auto-generated method stub
 763:         
 764:       }
 765: 
 766:       public Accessible getAccessibleRowDescription(int r)
 767:       {
 768:         // TODO Auto-generated method stub
 769:         return null;
 770:       }
 771: 
 772:       public void setAccessibleRowDescription(int r, Accessible description)
 773:       {
 774:         // TODO Auto-generated method stub
 775:         
 776:       }
 777: 
 778:       public Accessible getAccessibleColumnDescription(int c)
 779:       {
 780:         // TODO Auto-generated method stub
 781:         return null;
 782:       }
 783: 
 784:       public void setAccessibleColumnDescription(int c, Accessible description)
 785:       {
 786:         // TODO Auto-generated method stub
 787:         
 788:       }
 789: 
 790:       public boolean isAccessibleSelected(int r, int c)
 791:       {
 792:         // TODO Auto-generated method stub
 793:         return false;
 794:       }
 795: 
 796:       public boolean isAccessibleRowSelected(int r)
 797:       {
 798:         // TODO Auto-generated method stub
 799:         return false;
 800:       }
 801: 
 802:       public boolean isAccessibleColumnSelected(int c)
 803:       {
 804:         // TODO Auto-generated method stub
 805:         return false;
 806:       }
 807: 
 808:       public int[] getSelectedAccessibleRows()
 809:       {
 810:         // TODO Auto-generated method stub
 811:         return null;
 812:       }
 813: 
 814:       public int[] getSelectedAccessibleColumns()
 815:       {
 816:         // TODO Auto-generated method stub
 817:         return null;
 818:       }
 819:         
 820:     }
 821: 
 822:     /**
 823:      * The RI returns an instance of such class for table header cells. This
 824:      * makes sense so I added this class. This still needs to be fully
 825:      * implemented, I just don't feel motivated enough to do so just now.
 826:      */
 827:     private class AccessibleJTableHeaderCell
 828:       extends AccessibleContext
 829:       implements Accessible, AccessibleComponent
 830:     {
 831: 
 832:       JTableHeader header;
 833:       
 834:       int columnIndex;
 835:       
 836:       /**
 837:        * 
 838:        * @param h  the table header.
 839:        * @param comp
 840:        * @param r
 841:        * @param c  the column index.
 842:        */
 843:       private AccessibleJTableHeaderCell(JTableHeader h, Component comp, int r,
 844:                                          int c)
 845:       {
 846:         header = h;
 847:         columnIndex = c;
 848:       }
 849: 
 850:       /**
 851:        * Returns the header renderer.
 852:        * 
 853:        * @return The header renderer.
 854:        */
 855:       Component getColumnHeaderRenderer()
 856:       {
 857:         TableColumn tc = header.getColumnModel().getColumn(columnIndex);
 858:         TableCellRenderer r = tc.getHeaderRenderer();
 859:         if (r == null)
 860:           r = header.getDefaultRenderer();
 861:         return r.getTableCellRendererComponent(header.getTable(), 
 862:             tc.getHeaderValue(), false, false, -1, columnIndex);
 863:       }
 864:       
 865:       /**
 866:        * Returns the accessible role for the table header cell.
 867:        * 
 868:        * @return The accessible role.
 869:        */
 870:       public AccessibleRole getAccessibleRole()
 871:       {
 872:         Component renderer = getColumnHeaderRenderer();
 873:         if (renderer instanceof Accessible)
 874:           {
 875:             Accessible ac = (Accessible) renderer;
 876:             return ac.getAccessibleContext().getAccessibleRole();
 877:           }
 878:         return null;
 879:       }
 880: 
 881:       public AccessibleStateSet getAccessibleStateSet()
 882:       {
 883:         // TODO Auto-generated method stub
 884:         return null;
 885:       }
 886: 
 887:       public int getAccessibleIndexInParent()
 888:       {
 889:         // TODO Auto-generated method stub
 890:         return 0;
 891:       }
 892: 
 893:       public int getAccessibleChildrenCount()
 894:       {
 895:         // TODO Auto-generated method stub
 896:         return 0;
 897:       }
 898: 
 899:       public Accessible getAccessibleChild(int i)
 900:       {
 901:         // TODO Auto-generated method stub
 902:         return null;
 903:       }
 904: 
 905:       public Locale getLocale()
 906:       {
 907:         // TODO Auto-generated method stub
 908:         return null;
 909:       }
 910: 
 911:       /**
 912:        * Returns the accessible context.
 913:        * 
 914:        * @return <code>this</code>.
 915:        */
 916:       public AccessibleContext getAccessibleContext()
 917:       {
 918:         return this;
 919:       }
 920: 
 921:       public Color getBackground()
 922:       {
 923:         // TODO Auto-generated method stub
 924:         return null;
 925:       }
 926: 
 927:       public void setBackground(Color color)
 928:       {
 929:         // TODO Auto-generated method stub
 930:         
 931:       }
 932: 
 933:       public Color getForeground()
 934:       {
 935:         // TODO Auto-generated method stub
 936:         return null;
 937:       }
 938: 
 939:       public void setForeground(Color color)
 940:       {
 941:         // TODO Auto-generated method stub
 942:         
 943:       }
 944: 
 945:       public Cursor getCursor()
 946:       {
 947:         // TODO Auto-generated method stub
 948:         return null;
 949:       }
 950: 
 951:       public void setCursor(Cursor cursor)
 952:       {
 953:         // TODO Auto-generated method stub
 954:         
 955:       }
 956: 
 957:       public Font getFont()
 958:       {
 959:         // TODO Auto-generated method stub
 960:         return null;
 961:       }
 962: 
 963:       public void setFont(Font font)
 964:       {
 965:         // TODO Auto-generated method stub
 966:         
 967:       }
 968: 
 969:       public FontMetrics getFontMetrics(Font font)
 970:       {
 971:         // TODO Auto-generated method stub
 972:         return null;
 973:       }
 974: 
 975:       public boolean isEnabled()
 976:       {
 977:         // TODO Auto-generated method stub
 978:         return false;
 979:       }
 980: 
 981:       public void setEnabled(boolean b)
 982:       {
 983:         // TODO Auto-generated method stub
 984:         
 985:       }
 986: 
 987:       public boolean isVisible()
 988:       {
 989:         // TODO Auto-generated method stub
 990:         return false;
 991:       }
 992: 
 993:       public void setVisible(boolean b)
 994:       {
 995:         // TODO Auto-generated method stub
 996:         
 997:       }
 998: 
 999:       public boolean isShowing()
1000:       {
1001:         // TODO Auto-generated method stub
1002:         return false;
1003:       }
1004: 
1005:       public boolean contains(Point point)
1006:       {
1007:         // TODO Auto-generated method stub
1008:         return false;
1009:       }
1010: 
1011:       public Point getLocationOnScreen()
1012:       {
1013:         // TODO Auto-generated method stub
1014:         return null;
1015:       }
1016: 
1017:       public Point getLocation()
1018:       {
1019:         // TODO Auto-generated method stub
1020:         return null;
1021:       }
1022: 
1023:       public void setLocation(Point point)
1024:       {
1025:         // TODO Auto-generated method stub
1026:         
1027:       }
1028: 
1029:       public Rectangle getBounds()
1030:       {
1031:         // TODO Auto-generated method stub
1032:         return null;
1033:       }
1034: 
1035:       public void setBounds(Rectangle rectangle)
1036:       {
1037:         // TODO Auto-generated method stub
1038:         
1039:       }
1040: 
1041:       public Dimension getSize()
1042:       {
1043:         // TODO Auto-generated method stub
1044:         return null;
1045:       }
1046: 
1047:       public void setSize(Dimension dimension)
1048:       {
1049:         // TODO Auto-generated method stub
1050:         
1051:       }
1052: 
1053:       public Accessible getAccessibleAt(Point point)
1054:       {
1055:         // TODO Auto-generated method stub
1056:         return null;
1057:       }
1058: 
1059:       public boolean isFocusTraversable()
1060:       {
1061:         // TODO Auto-generated method stub
1062:         return false;
1063:       }
1064: 
1065:       public void requestFocus()
1066:       {
1067:         // TODO Auto-generated method stub
1068:         
1069:       }
1070: 
1071:       public void addFocusListener(FocusListener listener)
1072:       {
1073:         // TODO Auto-generated method stub
1074:         
1075:       }
1076: 
1077:       public void removeFocusListener(FocusListener listener)
1078:       {
1079:         // TODO Auto-generated method stub
1080:         
1081:       }
1082:       
1083:     }
1084: 
1085:     /**
1086:      * The last selected row. This is needed to track the selection in
1087:      * {@link #valueChanged(ListSelectionEvent)}.
1088:      */
1089:     private int lastSelectedRow;
1090: 
1091:     /**
1092:      * The last selected column. This is needed to track the selection in
1093:      * {@link #valueChanged(ListSelectionEvent)}.
1094:      */
1095:     private int lastSelectedColumn;
1096: 
1097:     /**
1098:      * The caption of the table.
1099:      */
1100:     private Accessible caption;
1101: 
1102:     /**
1103:      * The summary of the table.
1104:      */
1105:     private Accessible summary;
1106: 
1107:     /**
1108:      * Accessible descriptions for rows.
1109:      */
1110:     private Accessible[] rowDescriptions;
1111: 
1112:     /**
1113:      * Accessible descriptions for columns.
1114:      */
1115:     private Accessible[] columnDescriptions;
1116: 
1117:     /**
1118:      * Creates a new <code>AccessibleJTable</code>.
1119:      *
1120:      * @since JDK1.5
1121:      */
1122:     protected AccessibleJTable()
1123:     {
1124:       getModel().addTableModelListener(this);
1125:       getSelectionModel().addListSelectionListener(this);
1126:       getColumnModel().addColumnModelListener(this);
1127:       lastSelectedRow = getSelectedRow();
1128:       lastSelectedColumn = getSelectedColumn();
1129:       TableCellEditor editor = getCellEditor();
1130:       if (editor != null)
1131:         editor.addCellEditorListener(this);
1132:     }
1133: 
1134:     /**
1135:      * Returns the accessible role for the <code>JTable</code> component.
1136:      *
1137:      * @return {@link AccessibleRole#TABLE}.
1138:      */
1139:     public AccessibleRole getAccessibleRole()
1140:     {
1141:       return AccessibleRole.TABLE;
1142:     }
1143:     
1144:     /**
1145:      * Returns the accessible table.
1146:      * 
1147:      * @return <code>this</code>.
1148:      */
1149:     public AccessibleTable getAccessibleTable()
1150:     {
1151:       return this;
1152:     }
1153:     
1154:     /**
1155:      * Returns the number of selected items in this table.
1156:      */
1157:     public int getAccessibleSelectionCount()
1158:     {
1159:       return getSelectedColumnCount();
1160:     }
1161: 
1162:     /**
1163:      * Returns the selected accessible object with the specified index
1164:      * <code>i</code>. This basically returns the i-th selected cell in the
1165:      * table when going though it row-wise, and inside the rows, column-wise.
1166:      *
1167:      * @param i the index of the selected object to find
1168:      *
1169:      * @return the selected accessible object with the specified index
1170:      *         <code>i</code>
1171:      */
1172:     public Accessible getAccessibleSelection(int i)
1173:     {
1174:       Accessible found = null;
1175: 
1176:       int[] selectedRows = getSelectedRows();
1177:       int[] selectedColumns = getSelectedColumns();
1178:       int numCols = getColumnCount();
1179:       int numRows = getRowCount();
1180: 
1181:       // We have to go through every selected row and column and count until we
1182:       // find the specified index. This is potentially inefficient, but I can't
1183:       // think of anything better atm.
1184:       if (getRowSelectionAllowed() && getColumnSelectionAllowed())
1185:         {
1186:           int current = -1;
1187:           int newIndex = current;
1188:           int lastSelectedRow = -1;
1189:           // Go through the selected rows array, don't forget the selected
1190:           // cells inside the not-selected rows' columns.
1191:           for (int j = 0; i < selectedRows.length; i++)
1192:             {
1193:               // Handle unselected rows between this selected and the last
1194:               // selected row, if any.
1195:               int selectedRow = selectedRows[j];
1196:               int r = -1;
1197:               int ci = -1;
1198:               for (r = lastSelectedRow + 1;
1199:                    r < selectedRow && current < i; r++)
1200:                 {
1201:                   for (ci = 0; ci < selectedColumns.length && current < i;
1202:                        ci++)
1203:                     {
1204:                       current++;
1205:                     }
1206:                 }
1207:               if (current == i)
1208:                 {
1209:                   // We found the cell in the above loops, now get out of here.
1210:                   found = getAccessibleChild(r * numCols
1211:                                              + selectedColumns[ci]);
1212:                   break;
1213:                 }
1214: 
1215:               // If we're still here, handle the current selected row.
1216:               if (current < i && current + numCols >= i)
1217:                 {
1218:                   // The cell must be in that row, which one is it?
1219:                   found = getAccessibleChild(r * numCols + (i - current));
1220:                   break;
1221:                 }
1222:               current += numCols;
1223:             }
1224:           if (found == null)
1225:             {
1226:               // The cell can still be in the last couple of unselected rows.
1227:               int r = 0;
1228:               int ci = 0;
1229:               for (r = lastSelectedRow + 1;
1230:                    r < numRows && current < i; r++)
1231:                 {
1232:                   for (ci = 0; ci < selectedColumns.length && current < i;
1233:                        ci++)
1234:                     {
1235:                       current++;
1236:                     }
1237:                 }
1238:               if (current == i)
1239:                 {
1240:                   // We found the cell in the above loops, now get out of here.
1241:                   found = getAccessibleChild(r * numCols
1242:                                              + selectedColumns[ci]);
1243:                 }
1244:             }
1245:         }
1246:       // One or more rows can be completely selected.
1247:       else if (getRowSelectionAllowed())
1248:         {
1249:           int c = i % numCols;
1250:           int r = selectedRows[i / numCols];
1251:           found = getAccessibleChild(r * numCols + c);
1252:         }
1253:       // One or more columns can be completely selected.
1254:       else if (getRowSelectionAllowed())
1255:         {
1256:           int numSelectedColumns = selectedColumns.length;
1257:           int c = selectedColumns[i % numSelectedColumns];
1258:           int r = i / numSelectedColumns;
1259:           found = getAccessibleChild(r * numCols + c);
1260:         }
1261: 
1262:       return found;
1263:     }
1264: 
1265:     /**
1266:      * Returns <code>true</code> if the accessible child with the index
1267:      * <code>i</code> is selected, <code>false</code> otherwise.
1268:      *
1269:      * @param i the index of the accessible to check
1270:      *
1271:      * @return <code>true</code> if the accessible child with the index
1272:      *         <code>i</code> is selected, <code>false</code> otherwise
1273:      */
1274:     public boolean isAccessibleChildSelected(int i)
1275:     {
1276:       int r = getAccessibleRowAtIndex(i);
1277:       int c = getAccessibleColumnAtIndex(i);
1278:       return isCellSelected(r, c);
1279:     }
1280: 
1281:     /**
1282:      * Adds the accessible child with the specified index <code>i</code> to the
1283:      * selection.
1284:      *
1285:      * @param i the index of the accessible child to add to the selection
1286:      */
1287:     public void addAccessibleSelection(int i)
1288:     {
1289:       int r = getAccessibleRowAtIndex(i);
1290:       int c = getAccessibleColumnAtIndex(i);
1291:       changeSelection(r, c, true, false);
1292:     }
1293: 
1294:     /**
1295:      * Removes the accessible child with the specified index <code>i</code>
1296:      * from the current selection. This will only work on tables that have
1297:      * cell selection enabled (<code>rowSelectionAllowed == false &&
1298:      * columnSelectionAllowed == false</code>).
1299:      *
1300:      * @param i the index of the accessible to be removed from the selection
1301:      */
1302:     public void removeAccessibleSelection(int i)
1303:     {
1304:       if (! getRowSelectionAllowed() && ! getColumnSelectionAllowed())
1305:         {
1306:           int r = getAccessibleRowAtIndex(i);
1307:           int c = getAccessibleColumnAtIndex(i);
1308:           removeRowSelectionInterval(r, r);
1309:           removeColumnSelectionInterval(c, c);
1310:         }
1311:     }
1312: 
1313:     /**
1314:      * Deselects all selected accessible children.
1315:      */
1316:     public void clearAccessibleSelection()
1317:     {
1318:       clearSelection();
1319:     }
1320: 
1321:     /**
1322:      * Selects all accessible children that can be selected. This will only
1323:      * work on tables that support multiple selections and that have individual
1324:      * cell selection enabled.
1325:      */
1326:     public void selectAllAccessibleSelection()
1327:     {
1328:       selectAll();
1329:     }
1330: 
1331:     /**
1332:      * Receives notification when the row selection changes and fires
1333:      * appropriate property change events.
1334:      *
1335:      * @param event the list selection event
1336:      */
1337:     public void valueChanged(ListSelectionEvent event)
1338:     {
1339:       firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
1340:                          Boolean.FALSE, Boolean.TRUE);
1341:       int r = getSelectedRow();
1342:       int c = getSelectedColumn();
1343:       if (r != lastSelectedRow || c != lastSelectedColumn)
1344:         {
1345:           Accessible o = getAccessibleAt(lastSelectedRow,
1346:                                          lastSelectedColumn);
1347:           Accessible n = getAccessibleAt(r, c);
1348:           firePropertyChange(AccessibleContext
1349:                              .ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY, o, n);
1350:           lastSelectedRow = r;
1351:           lastSelectedColumn = c;
1352:         }
1353:     }
1354: 
1355:     /**
1356:      * Receives notification when the table model changes. Depending on the
1357:      * type of change, this method calls {@link #tableRowsInserted} or
1358:      * {@link #tableRowsDeleted}.
1359:      *
1360:      * @param event the table model event
1361:      */
1362:     public void tableChanged(TableModelEvent event)
1363:     {
1364:       switch (event.getType())
1365:         {
1366:         case TableModelEvent.INSERT:
1367:           tableRowsInserted(event);
1368:           break;
1369:         case TableModelEvent.DELETE:
1370:           tableRowsDeleted(event);
1371:           break;
1372:         }
1373:     }
1374: 
1375:     /**
1376:      * Receives notification when one or more rows have been inserted into the
1377:      * table and fires appropriate property change events.
1378:      *
1379:      * @param event the table model event
1380:      */
1381:     public void tableRowsInserted(TableModelEvent event)
1382:     {
1383:       handleRowChange(event);
1384:     }
1385: 
1386:     /**
1387:      * Receives notification when one or more rows have been deleted from the
1388:      * table.
1389:      *
1390:      * @param event the table model event
1391:      */
1392:     public void tableRowsDeleted(TableModelEvent event)
1393:     {
1394:       handleRowChange(event);
1395:     }
1396: 
1397:     /**
1398:      * Fires a PropertyChangeEvent for inserted or deleted rows.
1399:      *
1400:      * @param event the table model event
1401:      */
1402:     private void handleRowChange(TableModelEvent event)
1403:     {
1404:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1405:                          null, null);
1406:       int firstColumn = event.getColumn();
1407:       int lastColumn = event.getColumn();
1408:       if (firstColumn == TableModelEvent.ALL_COLUMNS)
1409:         {
1410:           firstColumn = 0;
1411:           lastColumn = getColumnCount() - 1;
1412:         }
1413:       AccessibleJTableModelChange change = new AccessibleJTableModelChange
1414:          (event.getType(), event.getFirstRow(), event.getLastRow(),
1415:           firstColumn, lastColumn);
1416:       firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
1417:                          null, change);
1418:     }
1419: 
1420:     public void columnAdded(TableColumnModelEvent event)
1421:     {
1422:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1423:                          null, null);
1424:       handleColumnChange(AccessibleTableModelChange.INSERT,
1425:                          event.getFromIndex(), event.getToIndex());
1426:     }
1427: 
1428:     public void columnRemoved(TableColumnModelEvent event)
1429:     {
1430:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1431:                          null, null);
1432:       handleColumnChange(AccessibleTableModelChange.DELETE,
1433:                          event.getFromIndex(), event.getToIndex());
1434:     }
1435: 
1436:     public void columnMoved(TableColumnModelEvent event)
1437:     {
1438:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1439:                          null, null);
1440:       handleColumnChange(AccessibleTableModelChange.DELETE,
1441:                          event.getFromIndex(), event.getFromIndex());
1442:       handleColumnChange(AccessibleTableModelChange.INSERT,
1443:                          event.getFromIndex(), event.getToIndex());
1444:     }
1445: 
1446:     /**
1447:      * Fires a PropertyChangeEvent for inserted or deleted columns.
1448:      *
1449:      * @param type the type of change
1450:      * @param from the start of the change
1451:      * @param to the target of the change
1452:      */
1453:     private void handleColumnChange(int type, int from, int to)
1454:     {
1455:       AccessibleJTableModelChange change =
1456:         new AccessibleJTableModelChange(type, 0, 0, from, to);
1457:       firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
1458:                          null, change);
1459:     }
1460: 
1461:     public void columnMarginChanged(ChangeEvent event)
1462:     {
1463:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1464:                          null, null);
1465:     }
1466: 
1467:     public void columnSelectionChanged(ListSelectionEvent event)
1468:     {
1469:       // AFAICS, nothing is done here.
1470:     }
1471: 
1472:     public void editingCanceled(ChangeEvent event)
1473:     {
1474:       // AFAICS, nothing is done here.
1475:     }
1476: 
1477:     public void editingStopped(ChangeEvent event)
1478:     {
1479:       firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
1480:                          null, null);
1481:     }
1482: 
1483:     /**
1484:      * Receives notification when any of the JTable's properties changes. This
1485:      * is used to replace the listeners on the table's model, selection model,
1486:      * column model and cell editor.
1487:      *
1488:      * @param e the property change event
1489:      */
1490:     public void propertyChange(PropertyChangeEvent e)
1491:     {
1492:       String propName = e.getPropertyName(); 
1493:       if (propName.equals("tableModel"))
1494:         {
1495:           TableModel oldModel = (TableModel) e.getOldValue();
1496:           oldModel.removeTableModelListener(this);
1497:           TableModel newModel = (TableModel) e.getNewValue();
1498:           newModel.addTableModelListener(this);
1499:         }
1500:       else if (propName.equals("columnModel"))
1501:         {
1502:           TableColumnModel oldModel = (TableColumnModel) e.getOldValue();
1503:           oldModel.removeColumnModelListener(this);
1504:           TableColumnModel newModel = (TableColumnModel) e.getNewValue();
1505:           newModel.addColumnModelListener(this);
1506:         }
1507:       else if (propName.equals("selectionModel"))
1508:         {
1509:           ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue();
1510:           oldModel.removeListSelectionListener(this);
1511:           ListSelectionModel newModel = (ListSelectionModel) e.getNewValue();
1512:           newModel.addListSelectionListener(this);
1513:         }
1514:       else if (propName.equals("cellEditor"))
1515:         {
1516:           CellEditor oldEd = (CellEditor) e.getOldValue();
1517:           oldEd.removeCellEditorListener(this);
1518:           CellEditor newEd = (CellEditor) e.getNewValue();
1519:           newEd.addCellEditorListener(this);
1520:         }
1521:     }
1522: 
1523:     /**
1524:      * Returns the row number of an accessible child (cell) with the specified
1525:      * index.
1526:      *
1527:      * @param index the index of the cell of which the row number is queried
1528:      * 
1529:      * @return the row number of an accessible child (cell) with the specified
1530:      *         index 
1531:      */
1532:     public int getAccessibleRow(int index)
1533:     {
1534:       return getAccessibleRowAtIndex(index);
1535:     }
1536: 
1537:     /**
1538:      * Returns the column number of an accessible child (cell) with the
1539:      * specified index.
1540:      *
1541:      * @param index the index of the cell of which the column number is queried
1542:      * 
1543:      * @return the column number of an accessible child (cell) with the
1544:      *         specified index 
1545:      */
1546:     public int getAccessibleColumn(int index)
1547:     {
1548:       return getAccessibleColumnAtIndex(index);
1549:     }
1550: 
1551:     /**
1552:      * Returns the index of the accessible child at the specified row and
1553:      * column.
1554:      *
1555:      * @param r the row number
1556:      * @param c the column number
1557:      *
1558:      * @return the index of the accessible child at the specified row and
1559:      *         column
1560:      */
1561:     public int getAccessibleIndex(int r, int c)
1562:     {
1563:       return getAccessibleIndexAt(r, c);
1564:     }
1565: 
1566:     /**
1567:      * Returns the caption of the table.
1568:      *
1569:      * @return the caption of the table
1570:      *
1571:      * @see #setAccessibleCaption(Accessible)
1572:      */
1573:     public Accessible getAccessibleCaption()
1574:     {
1575:       return caption;
1576:     }
1577: 
1578:     /**
1579:      * Sets the caption for the table.
1580:      *
1581:      * @param c the caption to set
1582:      */
1583:     public void setAccessibleCaption(Accessible c)
1584:     {
1585:       caption = c;
1586:     }
1587: 
1588:     /**
1589:      * Returns the summary for the table.
1590:      *
1591:      * @return the summary for the table
1592:      */
1593:     public Accessible getAccessibleSummary()
1594:     {
1595:       return summary;
1596:     }
1597: 
1598:     /**
1599:      * Sets the summary for the table.
1600:      *
1601:      * @param s the summary to set
1602:      */
1603:     public void setAccessibleSummary(Accessible s)
1604:     {
1605:       summary = s;
1606:     }
1607: 
1608:     /**
1609:      * Returns the number of rows in the table.
1610:      *
1611:      * @return the number of rows in the table
1612:      */
1613:     public int getAccessibleRowCount()
1614:     {
1615:       return getRowCount();
1616:     }
1617: 
1618:     /**
1619:      * Returns the number of columns in the table.
1620:      *
1621:      * @return the number of columns in the table
1622:      */
1623:     public int getAccessibleColumnCount()
1624:     {
1625:       return getColumnCount();
1626:     }
1627: 
1628:     /**
1629:      * Returns the accessible child at the given index.
1630:      *
1631:      * @param index  the child index.
1632:      * 
1633:      * @return The accessible child.
1634:      */
1635:     public Accessible getAccessibleChild(int index)
1636:     {
1637:       int r = getAccessibleRow(index);
1638:       int c = getAccessibleColumn(index);
1639:       return getAccessibleAt(r, c);  
1640:     }
1641:     
1642:     /**
1643:      * Returns the accessible child (table cell) at the specified row and
1644:      * column.
1645:      *
1646:      * @param r the row number
1647:      * @param c the column number
1648:      *
1649:      * @return the accessible child (table cell) at the specified row and
1650:      *         column
1651:      */
1652:     public Accessible getAccessibleAt(int r, int c)
1653:     {
1654:       TableCellRenderer cellRenderer = getCellRenderer(r, c);
1655:       Component renderer = cellRenderer.getTableCellRendererComponent(
1656:           JTable.this, getValueAt(r, c), isCellSelected(r, c), false, r, c);
1657:       if (renderer instanceof Accessible)
1658:         return (Accessible) renderer;
1659:       return null;
1660:     }
1661: 
1662:     /**
1663:      * Returns the number of rows that the specified cell occupies. The
1664:      * standard table cells only occupy one row, so we return <code>1</code>
1665:      * here.
1666:      *
1667:      * @param r the row number
1668:      * @param c the column number
1669:      *
1670:      * @return the number of rows that the specified cell occupies
1671:      */
1672:     public int getAccessibleRowExtentAt(int r, int c)
1673:     {
1674:       return 1;
1675:     }
1676: 
1677:     /**
1678:      * Returns the number of columns that the specified cell occupies. The
1679:      * standard table cells only occupy one column, so we return <code>1</code>
1680:      * here.
1681:      *
1682:      * @param r the row number
1683:      * @param c the column number
1684:      *
1685:      * @return the number of rows that the specified cell occupies
1686:      */
1687:     public int getAccessibleColumnExtentAt(int r, int c)
1688:     {
1689:       return 1;
1690:     }
1691: 
1692:     /**
1693:      * Returns the accessible row header.
1694:      *
1695:      * @return the accessible row header
1696:      */
1697:     public AccessibleTable getAccessibleRowHeader()
1698:     {
1699:       // The RI seems to always return null here, so do we.
1700:       return null;
1701:     }
1702: 
1703:     /**
1704:      * Sets the accessible row header.
1705:      *
1706:      * @param header the header to set
1707:      */
1708:     public void setAccessibleRowHeader(AccessibleTable header)
1709:     {
1710:       // In the RI this seems to be a no-op.    
1711:     }
1712: 
1713:     /**
1714:      * Returns the column header.
1715:      *
1716:      * @return the column header, or <code>null</code> if there is no column
1717:      *         header
1718:      */
1719:     public AccessibleTable getAccessibleColumnHeader()
1720:     {
1721:       JTableHeader h = getTableHeader();
1722:       AccessibleTable header = null;
1723:       if (h != null)
1724:         header = new AccessibleTableHeader(h);
1725:       return header;
1726:     }
1727: 
1728:     /**
1729:      * Sets the accessible column header. The default implementation doesn't
1730:      * allow changing the header this way, so this is a no-op.
1731:      *
1732:      * @param header the accessible column header to set
1733:      */
1734:     public void setAccessibleColumnHeader(AccessibleTable header)
1735:     {
1736:       // The RI doesn't seem to do anything, so we also do nothing.
1737:     }
1738: 
1739:     /**
1740:      * Returns the accessible description for the row with the specified index,
1741:      * or <code>null</code> if no description has been set.
1742:      *
1743:      * @param r the row for which the description is queried
1744:      *
1745:      * @return the accessible description for the row with the specified index,
1746:      *         or <code>null</code> if no description has been set
1747:      */
1748:     public Accessible getAccessibleRowDescription(int r)
1749:     {
1750:       Accessible descr = null;
1751:       if (rowDescriptions != null)
1752:         descr = rowDescriptions[r];
1753:       return descr;
1754:     }
1755: 
1756:     /**
1757:      * Sets the accessible description for the row with the specified index.
1758:      *
1759:      * @param r the row number for which to set the description
1760:      * @param description the description to set
1761:      */
1762:     public void setAccessibleRowDescription(int r, Accessible description)
1763:     {
1764:       if (rowDescriptions == null)
1765:         rowDescriptions = new Accessible[getAccessibleRowCount()];
1766:       rowDescriptions[r] = description;
1767:     }
1768: 
1769:     /**
1770:      * Returns the accessible description for the column with the specified
1771:      * index, or <code>null</code> if no description has been set.
1772:      *
1773:      * @param c the column for which the description is queried
1774:      *
1775:      * @return the accessible description for the column with the specified
1776:      *         index, or <code>null</code> if no description has been set
1777:      */
1778:     public Accessible getAccessibleColumnDescription(int c)
1779:     {
1780:       Accessible descr = null;
1781:       if (columnDescriptions != null)
1782:         descr = columnDescriptions[c];
1783:       return descr;
1784:     }
1785: 
1786:     /**
1787:      * Sets the accessible description for the column with the specified index.
1788:      *
1789:      * @param c the column number for which to set the description
1790:      * @param description the description to set
1791:      */
1792:     public void setAccessibleColumnDescription(int c, Accessible description)
1793:     {
1794:       if (columnDescriptions == null)
1795:         columnDescriptions = new Accessible[getAccessibleRowCount()];
1796:       columnDescriptions[c] = description;
1797:     }
1798: 
1799:     /**
1800:      * Returns <code>true</code> if the accessible child at the specified
1801:      * row and column is selected, <code>false</code> otherwise.
1802:      *
1803:      * @param r the row number of the child
1804:      * @param c the column number of the child
1805:      *
1806:      * @return <code>true</code> if the accessible child at the specified
1807:      *         row and column is selected, <code>false</code> otherwise
1808:      */
1809:     public boolean isAccessibleSelected(int r, int c)
1810:     {
1811:       return isCellSelected(r, c);
1812:     }
1813: 
1814:     /**
1815:      * Returns <code>true</code> if the row with the specified index is
1816:      * selected, <code>false</code> otherwise.
1817:      *
1818:      * @param r the row number
1819:      *
1820:      * @return <code>true</code> if the row with the specified index is
1821:      *        selected, <code>false</code> otherwise
1822:      */
1823:     public boolean isAccessibleRowSelected(int r)
1824:     {
1825:       return isRowSelected(r);
1826:     }
1827: 
1828:     /**
1829:      * Returns <code>true</code> if the column with the specified index is
1830:      * selected, <code>false</code> otherwise.
1831:      *
1832:      * @param c the column number
1833:      *
1834:      * @return <code>true</code> if the column with the specified index is
1835:      *        selected, <code>false</code> otherwise
1836:      */
1837:     public boolean isAccessibleColumnSelected(int c)
1838:     {
1839:       return isColumnSelected(c);
1840:     }
1841: 
1842:     /**
1843:      * Returns the indices of all selected rows.
1844:      *
1845:      * @return the indices of all selected rows
1846:      */
1847:     public int[] getSelectedAccessibleRows()
1848:     {
1849:       return getSelectedRows();
1850:     }
1851: 
1852:     /**
1853:      * Returns the indices of all selected columns.
1854:      *
1855:      * @return the indices of all selected columns
1856:      */
1857:     public int[] getSelectedAccessibleColumns()
1858:     {
1859:       return getSelectedColumns();
1860:     }
1861: 
1862:     /**
1863:      * Returns the accessible row at the specified index.
1864:      *
1865:      * @param index the index for which to query the row
1866:      *
1867:      * @return the row number at the specified table index
1868:      */
1869:     public int getAccessibleRowAtIndex(int index)
1870:     {
1871:       // TODO: Back this up by a Mauve test and update API docs accordingly.
1872:       return index / getColumnCount();
1873:     }
1874: 
1875:     /**
1876:      * Returns the accessible column at the specified index.
1877:      *
1878:      * @param index the index for which to query the column
1879:      *
1880:      * @return the column number at the specified table index
1881:      */
1882:     public int getAccessibleColumnAtIndex(int index)
1883:     {
1884:       // TODO: Back this up by a Mauve test and update API docs accordingly.
1885:       return index % getColumnCount();
1886:     }
1887: 
1888:     /**
1889:      * Returns the accessible child index at the specified column and row.
1890:      *
1891:      * @param row the row
1892:      * @param column the column
1893:      *
1894:      * @return the index of the accessible child at the specified row and
1895:      *         column
1896:      */
1897:     public int getAccessibleIndexAt(int row, int column)
1898:     {
1899:       // TODO: Back this up by a Mauve test and update API docs accordingly.
1900:       return row * getColumnCount() + column;
1901:     }
1902:   }
1903:   /**
1904:    * Handles property changes from the <code>TableColumn</code>s of this
1905:    * <code>JTable</code>.
1906:    *
1907:    * More specifically, this triggers a {@link #revalidate()} call if the
1908:    * preferredWidth of one of the observed columns changes.
1909:    */
1910:   class TableColumnPropertyChangeHandler implements PropertyChangeListener
1911:   {
1912:     /**
1913:      * Receives notification that a property of the observed TableColumns has
1914:      * changed.
1915:      * 
1916:      * @param ev the property change event
1917:      */
1918:     public void propertyChange(PropertyChangeEvent ev)
1919:     {
1920:       if (ev.getPropertyName().equals("preferredWidth"))
1921:         {
1922:           JTableHeader header = getTableHeader();
1923:           if (header != null)
1924:             // Do nothing if the table is in the resizing mode.
1925:             if (header.getResizingColumn() == null)
1926:               {
1927:                 TableColumn col = (TableColumn) ev.getSource();
1928:                 header.setResizingColumn(col);
1929:                 doLayout();
1930:                 header.setResizingColumn(null);
1931:               }
1932:         }
1933:     }
1934:   }
1935: 
1936:   /**
1937:    * A cell renderer for boolean values.
1938:    */
1939:   private class BooleanCellRenderer
1940:     extends DefaultTableCellRenderer
1941:   {
1942:     /**
1943:      * The CheckBox that is used for rendering.
1944:      */
1945:     private final JCheckBox checkBox;
1946:     
1947:     /**
1948:      * Creates a new checkbox based boolean cell renderer. The checkbox is
1949:      * centered by default.
1950:      */
1951:     BooleanCellRenderer()
1952:     {
1953:        checkBox = new JCheckBox();
1954:        checkBox.setHorizontalAlignment(SwingConstants.CENTER);
1955:     }
1956:    
1957:     /**
1958:      * Get the check box.
1959:      */
1960:     JCheckBox getCheckBox()
1961:     {
1962:       return checkBox;
1963:     }
1964: 
1965:     /**
1966:      * Returns the component that is used for rendering the value.
1967:      * 
1968:      * @param table the JTable
1969:      * @param value the value of the object
1970:      * @param isSelected is the cell selected?
1971:      * @param hasFocus has the cell the focus?
1972:      * @param row the row to render
1973:      * @param column the cell to render
1974:      * @return this component (the default table cell renderer)
1975:      */
1976:     public Component getTableCellRendererComponent(JTable table, Object value,
1977:                                                    boolean isSelected,
1978:                                                    boolean hasFocus, int row,
1979:                                                    int column)
1980:     {
1981:       if (isSelected)
1982:         {
1983:           checkBox.setBackground(table.getSelectionBackground());
1984:           checkBox.setForeground(table.getSelectionForeground());
1985:         }
1986:       else
1987:         {
1988:           checkBox.setBackground(table.getBackground());
1989:           checkBox.setForeground(table.getForeground());
1990:         }
1991: 
1992:       if (hasFocus)
1993:         {
1994:           checkBox.setBorder(
1995:             UIManager.getBorder("Table.focusCellHighlightBorder"));
1996:           if (table.isCellEditable(row, column))
1997:             {
1998:               checkBox.setBackground(
1999:                 UIManager.getColor("Table.focusCellBackground"));
2000:               checkBox.setForeground(
2001:                 UIManager.getColor("Table.focusCellForeground"));
2002:             }
2003:         }
2004:       else
2005:         checkBox.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
2006: 
2007:       // Null is rendered as false.
2008:       if (value == null)
2009:         checkBox.setSelected(false);
2010:       else
2011:         {
2012:           Boolean boolValue = (Boolean) value;
2013:           checkBox.setSelected(boolValue.booleanValue());
2014:         }
2015:       return checkBox;
2016:     }
2017:   }
2018: 
2019:   /**
2020:    * A cell renderer for Date values.
2021:    */
2022:   private class DateCellRenderer
2023:     extends DefaultTableCellRenderer
2024:   {
2025:     /**
2026:      * Returns the component that is used for rendering the value.
2027:      *
2028:      * @param table the JTable
2029:      * @param value the value of the object
2030:      * @param isSelected is the cell selected?
2031:      * @param hasFocus has the cell the focus?
2032:      * @param row the row to render
2033:      * @param column the cell to render
2034:      * 
2035:      * @return this component (the default table cell renderer)
2036:      */
2037:     public Component getTableCellRendererComponent(JTable table, Object value,
2038:                                                    boolean isSelected,
2039:                                                    boolean hasFocus, int row,
2040:                                                    int column)
2041:     {
2042:       super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2043:                                           row, column);
2044:       if (value instanceof Date)
2045:         {
2046:           Date dateValue = (Date) value;
2047:           DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
2048:           setText(df.format(dateValue));
2049:         }
2050:       return this;
2051:     }
2052:   }
2053: 
2054:   /**
2055:    * A cell renderer for Double values.
2056:    */
2057:   private class DoubleCellRenderer
2058:     extends DefaultTableCellRenderer
2059:   {
2060:     /**
2061:      * Creates a new instance of NumberCellRenderer.
2062:      */
2063:     public DoubleCellRenderer()
2064:     {
2065:       setHorizontalAlignment(JLabel.RIGHT);
2066:     }
2067: 
2068:     /**
2069:      * Returns the component that is used for rendering the value.
2070:      *
2071:      * @param table the JTable
2072:      * @param value the value of the object
2073:      * @param isSelected is the cell selected?
2074:      * @param hasFocus has the cell the focus?
2075:      * @param row the row to render
2076:      * @param column the cell to render
2077:      * 
2078:      * @return this component (the default table cell renderer)
2079:      */
2080:     public Component getTableCellRendererComponent(JTable table, Object value,
2081:                                                    boolean isSelected,
2082:                                                    boolean hasFocus, int row,
2083:                                                    int column)
2084:     {
2085:       super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2086:                                           row, column);
2087:       if (value instanceof Double)
2088:         {
2089:           Double doubleValue = (Double) value;
2090:           NumberFormat nf = NumberFormat.getInstance();
2091:           setText(nf.format(doubleValue.doubleValue()));
2092:         }
2093:       return this;
2094:     }
2095:   }
2096: 
2097:   /**
2098:    * A cell renderer for Float values.
2099:    */
2100:   private class FloatCellRenderer
2101:     extends DefaultTableCellRenderer
2102:   {
2103:     /**
2104:      * Creates a new instance of NumberCellRenderer.
2105:      */
2106:     public FloatCellRenderer()
2107:     {
2108:       setHorizontalAlignment(JLabel.RIGHT);
2109:     }
2110: 
2111:     /**
2112:      * Returns the component that is used for rendering the value.
2113:      *
2114:      * @param table the JTable
2115:      * @param value the value of the object
2116:      * @param isSelected is the cell selected?
2117:      * @param hasFocus has the cell the focus?
2118:      * @param row the row to render
2119:      * @param column the cell to render
2120:      * 
2121:      * @return this component (the default table cell renderer)
2122:      */
2123:     public Component getTableCellRendererComponent(JTable table, Object value,
2124:                                                    boolean isSelected,
2125:                                                    boolean hasFocus, int row,
2126:                                                    int column)
2127:     {
2128:       super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2129:                                           row, column);
2130:       if (value instanceof Float)
2131:         {
2132:           Float floatValue = (Float) value;
2133:           NumberFormat nf = NumberFormat.getInstance();
2134:           setText(nf.format(floatValue.floatValue()));
2135:         }
2136:       return this;
2137:     }
2138:   }
2139: 
2140:   /**
2141:    * A cell renderer for Number values.
2142:    */
2143:   private class NumberCellRenderer
2144:     extends DefaultTableCellRenderer
2145:   {
2146:     /**
2147:      * Creates a new instance of NumberCellRenderer.
2148:      */
2149:     public NumberCellRenderer()
2150:     {
2151:       setHorizontalAlignment(JLabel.RIGHT);
2152:     }
2153:   }
2154: 
2155:   /**
2156:    * A cell renderer for Icon values.
2157:    */
2158:   private class IconCellRenderer
2159:     extends DefaultTableCellRenderer
2160:   {
2161:     IconCellRenderer()
2162:     {
2163:       setHorizontalAlignment(SwingConstants.CENTER);
2164:     }
2165:     
2166:     
2167:     /**
2168:      * Returns the component that is used for rendering the value.
2169:      *
2170:      * @param table the JTable
2171:      * @param value the value of the object
2172:      * @param isSelected is the cell selected?
2173:      * @param hasFocus has the cell the focus?
2174:      * @param row the row to render
2175:      * @param column the cell to render
2176:      * 
2177:      * @return this component (the default table cell renderer)
2178:      */
2179:     public Component getTableCellRendererComponent(JTable table, Object value,
2180:                                                    boolean isSelected,
2181:                                                    boolean hasFocus, int row,
2182:                                                    int column)
2183:     {
2184:       super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
2185:                                           row, column);
2186:       if (value instanceof Icon)
2187:         {
2188:           Icon iconValue = (Icon) value;
2189:           setIcon(iconValue);
2190:         }
2191:       else
2192:         {
2193:           setIcon(null);
2194:         }
2195:       setText("");
2196:       return this;
2197:     }
2198:   }
2199:   
2200:     /**
2201:      * The JTable text component (used in editing) always has the table
2202:      * as its parent. The scrollRectToVisible must be adjusted taking the
2203:      * relative component position.
2204:      *
2205:      * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
2206:      */
2207:     private class TableTextField extends JTextField
2208:     {
2209:       /**
2210:        * Create the text field without the border.
2211:        */
2212:       TableTextField()
2213:       {
2214:         setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
2215:       }
2216:     }    
2217:   
2218: 
2219:   private static final long serialVersionUID = 3876025080382781659L;
2220:   
2221:   /**
2222:    * This table, for referring identically name methods from inner classes.
2223:    */
2224:   final JTable this_table = this;
2225: 
2226: 
2227:   /**
2228:    * When resizing columns, do not automatically change any columns. In this
2229:    * case the table should be enclosed in a {@link JScrollPane} in order to
2230:    * accomodate cases in which the table size exceeds its visible area.
2231:    */
2232:   public static final int AUTO_RESIZE_OFF = 0;
2233: 
2234:   /**
2235:    * When resizing column <code>i</code>, automatically change only the
2236:    * single column <code>i+1</code> to provide or absorb excess space
2237:    * requirements.
2238:    */
2239:   public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
2240: 
2241:   /**
2242:    * When resizing column <code>i</code> in a table of <code>n</code>
2243:    * columns, automatically change all columns in the range <code>[i+1,
2244:    * n)</code>, uniformly, to provide or absorb excess space requirements.
2245:    */
2246:   public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
2247:   
2248:   /**
2249:    * When resizing column <code>i</code> in a table of <code>n</code>
2250:    * columns, automatically change all columns in the range <code>[0,
2251:    * n)</code> (with the exception of column i) uniformly, to provide or
2252:    * absorb excess space requirements.
2253:    */
2254:   public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
2255: 
2256:   /**
2257:    * When resizing column <code>i</code> in a table of <code>n</code>
2258:    * columns, automatically change column <code>n-1</code> (the last column
2259:    * in the table) to provide or absorb excess space requirements.
2260:    */
2261:   public static final int AUTO_RESIZE_LAST_COLUMN = 3;
2262: 
2263:   /**
2264:    * A table mapping {@link java.lang.Class} objects to 
2265:    * {@link TableCellEditor} objects. This table is consulted by the 
2266:    * FIXME
2267:    */
2268:   protected Hashtable defaultEditorsByColumnClass = new Hashtable();
2269: 
2270:   /**
2271:    * A table mapping {@link java.lang.Class} objects to 
2272:    * {@link TableCellEditor} objects. This table is consulted by the 
2273:    * FIXME
2274:    */
2275:   protected Hashtable defaultRenderersByColumnClass = new Hashtable();
2276: 
2277:   /**
2278:    * The column that is edited, -1 if the table is not edited currently.
2279:    */
2280:   protected int editingColumn;
2281: 
2282:   /**
2283:    * The row that is edited, -1 if the table is not edited currently.
2284:    */
2285:   protected int editingRow;
2286: 
2287:   /**
2288:    * The component that is used for editing.
2289:    * <code>null</code> if the table is not editing currently.
2290:    *
2291:    */
2292:   protected transient Component editorComp;
2293: 
2294: 
2295:   /**
2296:    * Whether or not the table should automatically compute a matching
2297:    * {@link TableColumnModel} and assign it to the {@link #columnModel}
2298:    * property when the {@link #dataModel} property is changed. 
2299:    *
2300:    * @see #setModel(TableModel)
2301:    * @see #createDefaultColumnsFromModel()
2302:    * @see #setColumnModel(TableColumnModel)
2303:    * @see #setAutoCreateColumnsFromModel(boolean)
2304:    * @see #getAutoCreateColumnsFromModel()
2305:    */
2306:   protected boolean autoCreateColumnsFromModel;
2307: 
2308:   /**
2309:    * A numeric code specifying the resizing behavior of the table. Must be
2310:    * one of {@link #AUTO_RESIZE_ALL_COLUMNS} (the default), {@link
2311:    * #AUTO_RESIZE_LAST_COLUMN}, {@link #AUTO_RESIZE_NEXT_COLUMN}, {@link
2312:    * #AUTO_RESIZE_SUBSEQUENT_COLUMNS}, or {@link #AUTO_RESIZE_OFF}.
2313:    * 
2314:    * @see #doLayout()
2315:    * @see #setAutoResizeMode(int)
2316:    * @see #getAutoResizeMode()
2317:    */
2318:   protected int autoResizeMode;
2319: 
2320:   /**
2321:    * The height in pixels of any row of the table. All rows in a table are
2322:    * of uniform height. This differs from column width, which varies on a
2323:    * per-column basis, and is stored in the individual columns of the
2324:    * {@link #columnModel}.
2325:    * 
2326:    * @see #getRowHeight()
2327:    * @see #setRowHeight(int)
2328:    * @see TableColumn#getWidth()
2329:    * @see TableColumn#setWidth(int)
2330:    */
2331:   protected int rowHeight;
2332: 
2333:   /**
2334:    * The height in pixels of the gap left between any two rows of the table. 
2335:    * 
2336:    * @see #setRowMargin(int)
2337:    * @see #getRowHeight()
2338:    * @see #getIntercellSpacing()
2339:    * @see #setIntercellSpacing(Dimension)
2340:    * @see TableColumnModel#getColumnMargin()
2341:    * @see TableColumnModel#setColumnMargin(int)
2342:    */
2343:   protected int rowMargin;
2344: 
2345:   /**
2346:    * Whether or not the table should allow row selection. If the table
2347:    * allows both row <em>and</em> column selection, it is said to allow
2348:    * "cell selection". Previous versions of the JDK supported cell
2349:    * selection as an independent concept, but it is now represented solely
2350:    * in terms of simultaneous row and column selection.
2351:    *
2352:    * @see TableColumnModel#getColumnSelectionAllowed()
2353:    * @see #setRowSelectionAllowed(boolean)
2354:    * @see #getRowSelectionAllowed()
2355:    * @see #getCellSelectionEnabled()
2356:    * @see #setCellSelectionEnabled(boolean)
2357:    */
2358:   protected boolean rowSelectionAllowed;
2359: 
2360:   /**
2361:    * Obsolete. Use {@link #rowSelectionAllowed}, {@link 
2362:    * #getColumnSelectionAllowed}, or the combined methods {@link
2363:    * #getCellSelectionEnabled} and {@link #setCellSelectionEnabled(boolean)}.
2364:    */
2365:   protected boolean cellSelectionEnabled;
2366:   
2367:   /**
2368:    * The model for data stored in the table. Confusingly, the published API
2369:    * requires that this field be called <code>dataModel</code>, despite its
2370:    * property name. The table listens to its model as a {@link
2371:    * TableModelListener}.
2372:    *
2373:    * @see #tableChanged(TableModelEvent)
2374:    * @see TableModel#addTableModelListener(TableModelListener)
2375:    */
2376:   protected TableModel dataModel;
2377: 
2378:   /**
2379:    * <p>A model of various aspects of the columns of the table, <em>not
2380:    * including</em> the data stored in them. The {@link TableColumnModel}
2381:    * is principally concerned with holding a set of {@link TableColumn}
2382:    * objects, each of which describes the display parameters of a column
2383:    * and the numeric index of the column from the data model which the
2384:    * column is presenting.</p>
2385:    *
2386:    * <p>The TableColumnModel also contains a {@link ListSelectionModel} which
2387:    * indicates which columns are currently selected. This selection model
2388:    * works in combination with the {@link #selectionModel} of the table
2389:    * itself to specify a <em>table selection</em>: a combination of row and
2390:    * column selections.</p>
2391:    *
2392:    * <p>Most application programmers do not need to work with this property
2393:    * at all: setting {@link #autoCreateColumnsFromModel} will construct the
2394:    * columnModel automatically, and the table acts as a facade for most of
2395:    * the interesting properties of the columnModel anyways.</p>
2396:    * 
2397:    * @see #setColumnModel(TableColumnModel)
2398:    * @see #getColumnModel()
2399:    */
2400:   protected TableColumnModel columnModel;
2401: 
2402:   /**
2403:    * A model of the rows of this table which are currently selected. This
2404:    * model is used in combination with the column selection model held as a
2405:    * member of the {@link #columnModel} property, to represent the rows and
2406:    * columns (or both: cells) of the table which are currently selected.
2407:    *
2408:    * @see #rowSelectionAllowed
2409:    * @see #setSelectionModel(ListSelectionModel)
2410:    * @see #getSelectionModel()
2411:    * @see TableColumnModel#getSelectionModel()
2412:    * @see ListSelectionModel#addListSelectionListener(ListSelectionListener)   
2413:    */
2414:   protected ListSelectionModel selectionModel;
2415: 
2416:   /**
2417:    * The current cell editor. 
2418:    */
2419:   protected TableCellEditor cellEditor;
2420: 
2421:   /**
2422:    * Whether or not drag-and-drop is enabled on this table.
2423:    *
2424:    * @see #setDragEnabled(boolean)
2425:    * @see #getDragEnabled()
2426:    */
2427:   private boolean dragEnabled;
2428: 
2429:   /**
2430:    * The color to paint the grid lines of the table, when either {@link
2431:    * #showHorizontalLines} or {@link #showVerticalLines} is set.
2432:    *
2433:    * @see #setGridColor(Color)
2434:    * @see #getGridColor()
2435:    */
2436:   protected Color gridColor;
2437: 
2438:   /**
2439:    * The size this table would prefer its viewport assume, if it is
2440:    * contained in a {@link JScrollPane}.
2441:    *
2442:    * @see #setPreferredScrollableViewportSize(Dimension)
2443:    * @see #getPreferredScrollableViewportSize()
2444:    */
2445:   protected Dimension preferredViewportSize;
2446: 
2447:   /**
2448:    * The color to paint the background of selected cells. Fires a property
2449:    * change event with name {@link #SELECTION_BACKGROUND_CHANGED_PROPERTY}
2450:    * when its value changes.
2451:    *
2452:    * @see #setSelectionBackground(Color)
2453:    * @see #getSelectionBackground()
2454:    */
2455:   protected Color selectionBackground;
2456: 
2457:   /**
2458:    * The name carried in property change events when the {@link
2459:    * #selectionBackground} property changes.
2460:    */
2461:   private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
2462: 
2463:   /**
2464:    * The color to paint the foreground of selected cells. Fires a property
2465:    * change event with name {@link #SELECTION_FOREGROUND_CHANGED_PROPERTY}
2466:    * when its value changes.
2467:    *
2468:    * @see #setSelectionForeground(Color)
2469:    * @see #getSelectionForeground()
2470:    */
2471:   protected Color selectionForeground;
2472: 
2473:   /**
2474:    * The name carried in property change events when the
2475:    * {@link #selectionForeground} property changes.
2476:    */
2477:   private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
2478: 
2479:   /**
2480:    * The showHorizontalLines property.
2481:    */
2482:   protected boolean showHorizontalLines;
2483: 
2484:   /**
2485:    * The showVerticalLines property.
2486:    */
2487:   protected boolean showVerticalLines;
2488: 
2489:   /**
2490:    * The tableHeader property.
2491:    */
2492:   protected JTableHeader tableHeader;
2493: 
2494:   /**
2495:    * The property handler for this table's columns.
2496:    */
2497:   TableColumnPropertyChangeHandler tableColumnPropertyChangeHandler =
2498:     new TableColumnPropertyChangeHandler();
2499: 
2500:   /**
2501:    * Whether cell editors should receive keyboard focus when the table is
2502:    * activated.
2503:    */
2504:   private boolean surrendersFocusOnKeystroke = false;
2505: 
2506:   /**
2507:    * A Rectangle object to be reused in {@link #getCellRect}. 
2508:    */
2509:   private Rectangle rectCache = new Rectangle();
2510: 
2511:   /**
2512:    * Indicates if the rowHeight property has been set by a client program or by
2513:    * the UI.
2514:    *
2515:    * @see #setUIProperty(String, Object)
2516:    * @see LookAndFeel#installProperty(JComponent, String, Object)
2517:    */
2518:   private boolean clientRowHeightSet = false;
2519: 
2520:   /**
2521:    * Stores the sizes and positions of each row, when using non-uniform row
2522:    * heights. Initially the height of all rows is equal and stored in
2523:    * {link #rowHeight}. However, when an application calls
2524:    * {@link #setRowHeight(int,int)}, the table switches to non-uniform
2525:    * row height mode which stores the row heights in the SizeSequence
2526:    * object instead.
2527:    *
2528:    * @see #setRowHeight(int)
2529:    * @see #getRowHeight()
2530:    * @see #getRowHeight(int)
2531:    * @see #setRowHeight(int, int)
2532:    */
2533:   private SizeSequence rowHeights;
2534:   
2535:   /**
2536:    * This editor serves just a marker that the value must be simply changed to
2537:    * the opposite one instead of starting the editing session.
2538:    */
2539:   private transient TableCellEditor booleanInvertingEditor; 
2540:   
2541:   /**
2542:    * Creates a new <code>JTable</code> instance.
2543:    */
2544:   public JTable ()
2545:   {
2546:     this(null, null, null);
2547:   }
2548: 
2549:   /**
2550:    * Creates a new <code>JTable</code> instance with the given number
2551:    * of rows and columns.
2552:    *
2553:    * @param numRows an <code>int</code> value
2554:    * @param numColumns an <code>int</code> value
2555:    */
2556:   public JTable (int numRows, int numColumns)
2557:   {
2558:     this(new DefaultTableModel(numRows, numColumns));
2559:   }
2560: 
2561:   /**
2562:    * Creates a new <code>JTable</code> instance, storing the given data 
2563:    * array and heaving the given column names. To see the column names,
2564:    * you must place the JTable into the {@link JScrollPane}.
2565:    *
2566:    * @param data an <code>Object[][]</code> the table data
2567:    * @param columnNames an <code>Object[]</code> the column headers
2568:    */
2569:   public JTable(Object[][] data, Object[] columnNames)
2570:   {
2571:     this(new DefaultTableModel(data, columnNames));
2572:   }
2573: 
2574:   /**
2575:    * Creates a new <code>JTable</code> instance, using the given data model
2576:    * object that provides information about the table content. The table model
2577:    * object is asked for the table size, other features and also receives
2578:    * notifications in the case when the table has been edited by the user.
2579:    * 
2580:    * @param model
2581:    *          the table model.
2582:    */
2583:   public JTable (TableModel model)
2584:   {
2585:     this(model, null, null);
2586:   }
2587: 
2588:   /**
2589:    * Creates a new <code>JTable</code> instance, using the given model object
2590:    * that provides information about the table content. The table data model
2591:    * object is asked for the table size, other features and also receives
2592:    * notifications in the case when the table has been edited by the user. The
2593:    * table column model provides more detailed control on the table column
2594:    * related features.
2595:    * 
2596:    * @param dm
2597:    *          the table data mode
2598:    * @param cm
2599:    *          the table column model
2600:    */
2601:   public JTable (TableModel dm, TableColumnModel cm)
2602:   {
2603:     this(dm, cm, null);
2604:   }
2605: 
2606:   /**
2607:    * Creates a new <code>JTable</code> instance, providing data model,
2608:    * column model and list selection model. The list selection model
2609:    * manages the selections.
2610:    *
2611:    * @param dm data model (manages table data)
2612:    * @param cm column model (manages table columns)
2613:    * @param sm list selection model (manages table selections)
2614:    */
2615:   public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
2616:   {
2617:     boolean autoCreate = false;
2618:     TableColumnModel columnModel;
2619:     if (cm != null)
2620:         columnModel = cm;
2621:     else 
2622:       {
2623:         columnModel = createDefaultColumnModel();
2624:         autoCreate = true;
2625:       }
2626:     
2627:     // Initialise the intercelar spacing before setting the column model to
2628:     // avoid firing unnecessary events.
2629:     // The initial incellar spacing is new Dimenstion(1,1). 
2630:     rowMargin = 1;
2631:     columnModel.setColumnMargin(1);
2632:     setColumnModel(columnModel);
2633:     
2634:     setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
2635:     setModel(dm == null ? createDefaultDataModel() : dm);
2636:     setAutoCreateColumnsFromModel(autoCreate);
2637:     initializeLocalVars();
2638:     // The following four lines properly set the lead selection indices.
2639:     // After this, the UI will handle the lead selection indices.
2640:     // FIXME: this should probably not be necessary, if the UI is installed
2641:     // before the TableModel is set then the UI will handle things on its
2642:     // own, but certain variables need to be set before the UI can be installed
2643:     // so we must get the correct order for all the method calls in this
2644:     // constructor.
2645:     selectionModel.setAnchorSelectionIndex(0);    
2646:     selectionModel.setLeadSelectionIndex(0);
2647:     columnModel.getSelectionModel().setAnchorSelectionIndex(0);
2648:     columnModel.getSelectionModel().setLeadSelectionIndex(0);
2649:     updateUI();
2650:   }
2651:   
2652:   /**
2653:    * Creates a new <code>JTable</code> instance that uses data and column
2654:    * names, stored in {@link Vector}s.
2655:    *
2656:    * @param data the table data
2657:    * @param columnNames the table column names.
2658:    */
2659:   public JTable(Vector data, Vector columnNames)
2660:   {
2661:     this(new DefaultTableModel(data, columnNames));
2662:   }  
2663:   
2664:   /**
2665:    * Initialize local variables to default values.
2666:    */
2667:   protected void initializeLocalVars()
2668:   {
2669:     setTableHeader(createDefaultTableHeader());
2670:     if (autoCreateColumnsFromModel)
2671:       createDefaultColumnsFromModel();
2672:     this.columnModel.addColumnModelListener(this);
2673: 
2674:     this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
2675:     setRowHeight(16);
2676:     this.rowMargin = 1;
2677:     this.rowSelectionAllowed = true;
2678:     // this.accessibleContext = new AccessibleJTable();
2679:     this.cellEditor = null;
2680:     // COMPAT: Both Sun and IBM have drag enabled
2681:     this.dragEnabled = true;
2682:     this.preferredViewportSize = new Dimension(450,400);
2683:     this.showHorizontalLines = true;
2684:     this.showVerticalLines = true;
2685:     this.editingColumn = -1;
2686:     this.editingRow = -1;
2687:   }
2688:   
2689:   /**
2690:    * Add the new table column. The table column class allows to specify column
2691:    * features more precisely, setting the preferred width, column data type
2692:    * (column class) and table headers.
2693:    * 
2694:    * There is no need the add columns to the table if the default column 
2695:    * handling is sufficient.
2696:    * 
2697:    * @param column
2698:    *          the new column to add.
2699:    */
2700:   public void addColumn(TableColumn column)
2701:   {
2702:     if (column.getHeaderValue() == null)
2703:       {
2704:         String name = dataModel.getColumnName(column.getModelIndex());
2705:         column.setHeaderValue(name);
2706:       }
2707:     
2708:     columnModel.addColumn(column);
2709:     column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
2710:   }
2711:   
2712:   /**
2713:    * Create the default editors for this table. The default method creates
2714:    * the editor for Booleans.
2715:    * 
2716:    * Other fields are edited as strings at the moment.
2717:    */
2718:   protected void createDefaultEditors()
2719:   {
2720:     JCheckBox box = new BooleanCellRenderer().getCheckBox();
2721:     box.setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
2722:     box.setBorderPainted(true);
2723:     booleanInvertingEditor = new DefaultCellEditor(box);    
2724:     setDefaultEditor(Boolean.class, booleanInvertingEditor);
2725:   }
2726:   
2727:   /**
2728:    * Create the default renderers for this table. The default method creates
2729:    * renderers for Boolean, Number, Double, Date, Icon and ImageIcon.
2730:    *
2731:    */
2732:   protected void createDefaultRenderers()
2733:   {
2734:     setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
2735:     setDefaultRenderer(Number.class, new NumberCellRenderer());
2736:     setDefaultRenderer(Double.class, new DoubleCellRenderer());
2737:     setDefaultRenderer(Double.class, new FloatCellRenderer());
2738:     setDefaultRenderer(Date.class, new DateCellRenderer());
2739:     setDefaultRenderer(Icon.class, new IconCellRenderer());
2740:     setDefaultRenderer(ImageIcon.class, new IconCellRenderer());    
2741:   }
2742:   
2743:   /**
2744:    * @deprecated 1.0.2, replaced by <code>new JScrollPane(JTable)</code>
2745:    */
2746:   public static JScrollPane createScrollPaneForTable(JTable table)
2747:   {
2748:     return new JScrollPane(table);
2749:   }
2750:   
2751:   /**
2752:    * Create the default table column model that is used if the user-defined
2753:    * column model is not provided. The default method creates
2754:    * {@link DefaultTableColumnModel}.
2755:    * 
2756:    * @return the created table column model.
2757:    */
2758:   protected TableColumnModel createDefaultColumnModel()
2759:   {
2760:     return new DefaultTableColumnModel();
2761:   }
2762: 
2763:   /**
2764:    * Create the default table data model that is used if the user-defined
2765:    * data model is not provided. The default method creates
2766:    * {@link DefaultTableModel}.
2767:    * 
2768:    * @return the created table data model.
2769:    */
2770:   protected TableModel createDefaultDataModel()
2771:   {
2772:     return new DefaultTableModel();
2773:   }
2774: 
2775:   /**
2776:    * Create the default table selection model that is used if the user-defined
2777:    * selection model is not provided. The default method creates
2778:    * {@link DefaultListSelectionModel}.
2779:    * 
2780:    * @return the created table data model.
2781:    */
2782:   protected ListSelectionModel createDefaultSelectionModel()
2783:   {
2784:     return new DefaultListSelectionModel();
2785:   }
2786:   
2787:   /**
2788:    * Create the default table header, if the user - defined table header is not
2789:    * provided.
2790:    * 
2791:    * @return the default table header.
2792:    */
2793:   protected JTableHeader createDefaultTableHeader()
2794:   {
2795:     return new JTableHeader(columnModel);
2796:   }
2797:   
2798:   /**
2799:    * Invoked when the column is added. Revalidates and repains the table.
2800:    */
2801:   public void columnAdded (TableColumnModelEvent event)
2802:   {
2803:     revalidate();
2804:     repaint();
2805:   }
2806: 
2807:   /**
2808:    * Invoked when the column margin is changed. 
2809:    * Revalidates and repains the table.
2810:    */
2811:   public void columnMarginChanged (ChangeEvent event)
2812:   {
2813:     revalidate();
2814:     repaint();
2815:   }
2816: 
2817:   /**
2818:    * Invoked when the column is moved. Revalidates and repains the table.
2819:    */
2820:   public void columnMoved (TableColumnModelEvent event)
2821:   {
2822:     if (isEditing())
2823:       editingCanceled(null);
2824:     revalidate();
2825:     repaint();
2826:   }
2827: 
2828:   /**
2829:    * Invoked when the column is removed. Revalidates and repains the table.
2830:    */
2831:   public void columnRemoved (TableColumnModelEvent event)
2832:   {
2833:     revalidate();
2834:     repaint();
2835:   }
2836:   
2837:   /**
2838:    * Invoked when the the column selection changes, repaints the changed
2839:    * columns. It is not recommended to override this method, register the
2840:    * listener instead.
2841:    */
2842:   public void columnSelectionChanged (ListSelectionEvent event)
2843:   {
2844:     // We must limit the indices to the bounds of the JTable's model, because
2845:     // we might get values of -1 or greater then columnCount in the case
2846:     // when columns get removed.
2847:     int idx0 = Math.max(0, Math.min(getColumnCount() - 1,
2848:                                     event.getFirstIndex()));
2849:     int idxn = Math.max(0, Math.min(getColumnCount() - 1,
2850:                                     event.getLastIndex()));
2851: 
2852:     int minRow = 0;
2853:     int maxRow = getRowCount() - 1;
2854:     if (getRowSelectionAllowed())
2855:       {
2856:         minRow = selectionModel.getMinSelectionIndex();
2857:         maxRow = selectionModel.getMaxSelectionIndex();
2858:         int leadRow = selectionModel.getLeadSelectionIndex();
2859:         if (minRow == -1 && maxRow == -1)
2860:           {
2861:             minRow = leadRow;
2862:             maxRow = leadRow;
2863:           }
2864:         else
2865:           {
2866:             // In this case we need to repaint also the range to leadRow, not
2867:             // only between min and max.
2868:             if (leadRow != -1)
2869:               {
2870:                 minRow = Math.min(minRow, leadRow);
2871:                 maxRow = Math.max(maxRow, leadRow);
2872:               }
2873:           }
2874:       }
2875:     if (minRow != -1 && maxRow != -1)
2876:       {
2877:         Rectangle first = getCellRect(minRow, idx0, false);
2878:         Rectangle last = getCellRect(maxRow, idxn, false);
2879:         Rectangle dirty = SwingUtilities.computeUnion(first.x, first.y,
2880:                                                       first.width,
2881:                                                       first.height, last);
2882:         repaint(dirty);
2883:       }
2884:   }
2885:  
2886:   /**
2887:    * Invoked when the editing is cancelled.
2888:    */
2889:   public void editingCanceled (ChangeEvent event)
2890:   {
2891:     if (editorComp!=null)
2892:       {
2893:         remove(editorComp);
2894:         repaint(editorComp.getBounds());        
2895:         editorComp = null;
2896:       }
2897:   }
2898:   
2899:   /**
2900:    * Finish the current editing session and update the table with the
2901:    * new value by calling {@link #setValueAt}.
2902:    * 
2903:    * @param event the change event
2904:    */
2905:   public void editingStopped (ChangeEvent event)
2906:   {
2907:     if (editorComp!=null)
2908:       {
2909:         remove(editorComp);        
2910:         setValueAt(cellEditor.getCellEditorValue(), editingRow, editingColumn);            
2911:         repaint(editorComp.getBounds());
2912:         editorComp = null;
2913:       }
2914:     requestFocusInWindow();
2915:   }
2916: 
2917:   /**
2918:    * Invoked when the table changes.
2919:    * <code>null</code> means everything changed.
2920:    */
2921:   public void tableChanged (TableModelEvent event)
2922:   {
2923:     // update the column model from the table model if the structure has
2924:     // changed and the flag autoCreateColumnsFromModel is set
2925:     if ((event == null || (event.getFirstRow() == TableModelEvent.HEADER_ROW))
2926:     && autoCreateColumnsFromModel)
2927:       {
2928:         rowHeights = null;
2929:         if (getAutoCreateColumnsFromModel())
2930:           createDefaultColumnsFromModel();
2931:         resizeAndRepaint();
2932:         return;
2933:       }
2934: 
2935:     // If the structure changes, we need to revalidate, since that might
2936:     // affect the size parameters of the JTable. Otherwise we only need
2937:     // to perform a repaint to update the view.
2938:     if (event == null || event.getType() == TableModelEvent.INSERT)
2939:       {
2940:         // Sync selection model with data model.
2941:         if (event != null)
2942:           {
2943:             int first = event.getFirstRow();
2944:             if (first < 0)
2945:               first = 0;
2946:             int last = event.getLastRow();
2947:             if (last < 0)
2948:               last = getRowCount() - 1;
2949:             selectionModel.insertIndexInterval(first, last - first + 1, true);
2950:             if (rowHeights != null)
2951:               rowHeights.insertEntries(first, last - first + 1, rowHeight);
2952:           }
2953:         revalidate();
2954:       }
2955:     if (event == null || event.getType() == TableModelEvent.DELETE)
2956:       {
2957:         // Sync selection model with data model.
2958:         if (event != null)
2959:           {
2960:             int first = event.getFirstRow();
2961:             if (first < 0)
2962:               first = 0;
2963:             int last = event.getLastRow();
2964:             if (last < 0)
2965:               last = getRowCount() - 1;
2966:             selectionModel.removeIndexInterval(first, last);
2967:             if (rowHeights != null)
2968:               rowHeights.removeEntries(first, last - first + 1);
2969:           }
2970:         if (dataModel.getRowCount() == 0)
2971:           clearSelection();
2972:         revalidate();
2973:       }
2974:     repaint();
2975:   }
2976: 
2977:   /**
2978:    * Invoked when another table row is selected. It is not recommended
2979:    * to override thid method, register the listener instead.
2980:    */
2981:   public void valueChanged (ListSelectionEvent event)
2982:   {
2983:     // If we are in the editing process, end the editing session.
2984:     if (isEditing())
2985:       editingStopped(null);
2986:     
2987:     // Repaint the changed region.
2988:     int first = Math.max(0, Math.min(getRowCount() - 1, event.getFirstIndex()));
2989:     int last = Math.max(0, Math.min(getRowCount() - 1, event.getLastIndex()));
2990:     Rectangle rect1 = getCellRect(first, 0, false);
2991:     Rectangle rect2 = getCellRect(last, getColumnCount() - 1, false);
2992:     Rectangle dirty = SwingUtilities.computeUnion(rect2.x, rect2.y,
2993:                                                   rect2.width, rect2.height,
2994:                                                   rect1);
2995:     repaint(dirty);
2996:   }
2997: 
2998:  /**
2999:    * Returns index of the column that contains specified point 
3000:    * or -1 if this table doesn't contain this point.
3001:    *
3002:    * @param point point to identify the column
3003:    * @return index of the column that contains specified point or 
3004:    * -1 if this table doesn't contain this point.
3005:    */
3006:   public int columnAtPoint(Point point)
3007:   {
3008:     int ncols = getColumnCount();
3009:     Dimension gap = getIntercellSpacing();
3010:     TableColumnModel cols = getColumnModel();
3011:     int x = point.x;
3012: 
3013:     for (int i = 0; i < ncols; ++i)
3014:       {
3015:         int width = cols.getColumn(i).getWidth()
3016:                     + (gap == null ? 0 : gap.width);
3017:         if (0 <= x && x < width)
3018:           return i;
3019:         x -= width;
3020:       }
3021:     return -1;
3022:   }
3023: 
3024:   /**
3025:    * Returns index of the row that contains specified point or -1 if this table
3026:    * doesn't contain this point.
3027:    * 
3028:    * @param point point to identify the row
3029:    * @return index of the row that contains specified point or -1 if this table
3030:    *         doesn't contain this point.
3031:    */
3032:   public int rowAtPoint(Point point)
3033:   {
3034:     if (point != null)
3035:       {
3036:         int nrows = getRowCount();
3037:         int r;
3038:         int y = point.y;
3039:         if (rowHeights == null)
3040:           {
3041:             int height = getRowHeight();
3042:             r = y / height;
3043:           }
3044:         else
3045:           r = rowHeights.getIndex(y);
3046: 
3047:         if (r < 0 || r >= nrows)
3048:           return -1;
3049:         else
3050:           return r;
3051:       }
3052:     else
3053:       return -1;
3054:   }
3055: 
3056:   /** 
3057:    * Calculate the visible rectangle for a particular row and column. The
3058:    * row and column are specified in visual terms; the column may not match
3059:    * the {@link #dataModel} column.
3060:    *
3061:    * @param row the visible row to get the cell rectangle of
3062:    *
3063:    * @param column the visible column to get the cell rectangle of, which may
3064:    * differ from the {@link #dataModel} column
3065:    *
3066:    * @param includeSpacing whether or not to include the cell margins in the
3067:    * resulting cell. If <code>false</code>, the result will only contain the
3068:    * inner area of the target cell, not including its margins.
3069:    *
3070:    * @return a rectangle enclosing the specified cell
3071:    */
3072:   public Rectangle getCellRect(int row,
3073:                                int column,
3074:                                boolean includeSpacing)
3075:   {
3076:     Rectangle cellRect = new Rectangle(0, 0, 0, 0);
3077: 
3078:     // Check for valid range vertically.
3079:     if (row >= getRowCount())
3080:       {
3081:         cellRect.height = getHeight();
3082:       }
3083:     else if (row >= 0)
3084:       {
3085:         cellRect.height = getRowHeight(row);
3086:         if (rowHeights == null)
3087:           cellRect.y = row * cellRect.height;
3088:         else
3089:           cellRect.y = rowHeights.getPosition(row);
3090: 
3091:         if (! includeSpacing)
3092:           {
3093:             // The rounding here is important.
3094:             int rMargin = getRowMargin();
3095:             cellRect.y += rMargin / 2;
3096:             cellRect.height -= rMargin;
3097:           }
3098:       }
3099:     // else row < 0, y = height = 0
3100: 
3101:     // Check for valid range horizontally.
3102:     if (column < 0)
3103:       {
3104:         if (! getComponentOrientation().isLeftToRight())
3105:           {
3106:             cellRect.x = getWidth();
3107:           }
3108:       }
3109:     else if (column >= getColumnCount())
3110:       {
3111:         if (getComponentOrientation().isLeftToRight())
3112:           {
3113:             cellRect.x = getWidth();
3114:           }
3115:       }
3116:     else
3117:       {
3118:         TableColumnModel tcm = getColumnModel();
3119:         if (getComponentOrientation().isLeftToRight())
3120:           {
3121:             for (int i = 0; i < column; i++)
3122:               cellRect.x += tcm.getColumn(i).getWidth();
3123:           }
3124:         else
3125:           {
3126:             for (int i = tcm.getColumnCount() - 1; i > column; i--)
3127:               cellRect.x += tcm.getColumn(i).getWidth();
3128:           }
3129:         cellRect.width = tcm.getColumn(column).getWidth();
3130:         if (! includeSpacing)
3131:           {
3132:             // The rounding here is important.
3133:             int cMargin = tcm.getColumnMargin();
3134:             cellRect.x += cMargin / 2;
3135:             cellRect.width -= cMargin;
3136:           }
3137:       }
3138: 
3139:     return cellRect;
3140:   }
3141: 
3142:   public void clearSelection()
3143:   {
3144:     selectionModel.clearSelection();
3145:     getColumnModel().getSelectionModel().clearSelection();
3146:   }
3147: 
3148:   /**
3149:    * Get the value of the selectedRow property by delegation to
3150:    * the {@link ListSelectionModel#getMinSelectionIndex} method of the
3151:    * {@link #selectionModel} field.
3152:    *
3153:    * @return The current value of the selectedRow property
3154:    */
3155:   public int getSelectedRow ()
3156:   {    
3157:     return selectionModel.getMinSelectionIndex();
3158:   }
3159:   
3160:   /**
3161:    * Get the value of the {@link #selectionModel} property.
3162:    *
3163:    * @return The current value of the property
3164:    */
3165:   public ListSelectionModel getSelectionModel()
3166:   {
3167:     //Neither Sun nor IBM returns null if rowSelection not allowed
3168:     return selectionModel;
3169:   }
3170:   
3171:   public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
3172:   {
3173:     if (orientation == SwingConstants.VERTICAL)
3174:       return visibleRect.height * direction;
3175:     else
3176:       return visibleRect.width * direction;
3177:   }
3178: 
3179:   /**
3180:    * Get the value of the <code>scrollableTracksViewportHeight</code> property.
3181:    *
3182:    * @return The constant value <code>false</code>
3183:    */
3184:   public boolean getScrollableTracksViewportHeight()
3185:   {
3186:     return false;
3187:   }
3188:   
3189:   /**
3190:    * Get the value of the <code>scrollableTracksViewportWidth</code> property.
3191:    *
3192:    * @return <code>true</code> unless the {@link #autoResizeMode} property is
3193:    * <code>AUTO_RESIZE_OFF</code>
3194:    */
3195:   public boolean getScrollableTracksViewportWidth()
3196:   {
3197:     if (autoResizeMode == AUTO_RESIZE_OFF)
3198:       return false;
3199:     else
3200:       return true;
3201:   }
3202:   
3203:   /**
3204:    * Return the preferred scrolling amount (in pixels) for the given scrolling
3205:    * direction and orientation. This method handles a partially exposed row by
3206:    * returning the distance required to completely expose the item. When
3207:    * scrolling the top item is completely exposed.
3208:    * 
3209:    * @param visibleRect the currently visible part of the component.
3210:    * @param orientation the scrolling orientation
3211:    * @param direction the scrolling direction (negative - up, positive -down).
3212:    *          The values greater than one means that more mouse wheel or similar
3213:    *          events were generated, and hence it is better to scroll the longer
3214:    *          distance.
3215:    * @author Audrius Meskauskas (audriusa@bioinformatics.org)
3216:    */
3217:   public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
3218:                                         int direction)
3219:   {
3220:     int h = (rowHeight + rowMargin);
3221:     int delta = h * direction;
3222: 
3223:     // Round so that the top would start from the row boundary
3224:     if (orientation == SwingConstants.VERTICAL)
3225:       {
3226:         // Completely expose the top row
3227:         int near = ((visibleRect.y + delta + h / 2) / h) * h;
3228:         int diff = visibleRect.y + delta - near;
3229:         delta -= diff;
3230:       }
3231:     return delta;
3232:     // TODO when scrollng horizontally, scroll into the column boundary.
3233:   }
3234: 
3235:   /**
3236:    * Get the cell editor, suitable for editing the given cell. The default
3237:    * method requests the editor from the column model. If the column model does
3238:    * not provide the editor, the call is forwarded to the
3239:    * {@link #getDefaultEditor(Class)} with the parameter, obtained from
3240:    * {@link TableModel#getColumnClass(int)}.
3241:    * 
3242:    * @param row the cell row
3243:    * @param column the cell column
3244:    * @return the editor to edit that cell
3245:    */
3246:   public TableCellEditor getCellEditor(int row, int column)
3247:   {
3248:     TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
3249: 
3250:     if (editor == null)
3251:       {
3252:         int mcolumn = convertColumnIndexToModel(column);
3253:         editor = getDefaultEditor(dataModel.getColumnClass(mcolumn));
3254:       }
3255: 
3256:     return editor;
3257:   }
3258:   
3259:   /**
3260:    * Get the default editor for editing values of the given type
3261:    * (String, Boolean and so on).
3262:    * 
3263:    * @param columnClass the class of the value that will be edited.
3264:    * 
3265:    * @return the editor, suitable for editing this data type
3266:    */
3267:   public TableCellEditor getDefaultEditor(Class columnClass)
3268:   {
3269:     if (defaultEditorsByColumnClass.containsKey(columnClass))
3270:       return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
3271:     else
3272:       {
3273:         JTextField t = new TableTextField();        
3274:         TableCellEditor r = new DefaultCellEditor(t);
3275:         defaultEditorsByColumnClass.put(columnClass, r);
3276:         return r;
3277:       }
3278:   }
3279:   
3280:   /**
3281:    * Get the cell renderer for rendering the given cell.
3282:    * 
3283:    * @param row the cell row
3284:    * @param column the cell column
3285:    * @return the cell renderer to render that cell.
3286:    */
3287:   public TableCellRenderer getCellRenderer(int row, int column)
3288:   {
3289:     TableCellRenderer renderer = columnModel.getColumn(column).getCellRenderer();
3290:     if (renderer == null)
3291:       {
3292:         int mcolumn = convertColumnIndexToModel(column);
3293:         renderer = getDefaultRenderer(dataModel.getColumnClass(mcolumn));
3294:       }
3295:     return renderer;
3296:   }
3297:   
3298:   /**
3299:    * Set default renderer for rendering the given data type.
3300:    * 
3301:    * @param columnClass the data type (String, Boolean and so on) that must be
3302:    *          rendered.
3303:    * @param rend the renderer that will rend this data type
3304:    */
3305:   public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
3306:   {
3307:     defaultRenderersByColumnClass.put(columnClass, rend);
3308:   }
3309:   
3310:   /**
3311:    * Get the default renderer for rendering the given data type.
3312:    * 
3313:    * @param columnClass the data that must be rendered
3314:    * 
3315:    * @return the appropriate defauld renderer for rendering that data type.
3316:    */
3317:   public TableCellRenderer getDefaultRenderer(Class columnClass)
3318:   {
3319:     if (defaultRenderersByColumnClass.containsKey(columnClass))
3320:       return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
3321:     else
3322:       {
3323:         TableCellRenderer r = new DefaultTableCellRenderer();
3324:         defaultRenderersByColumnClass.put(columnClass, r);
3325:         return r;
3326:       }
3327:   }
3328:   
3329:   /**
3330:    * Convert the table model index into the table column number.
3331:    * The model number need not match the real column position. The columns
3332:    * may be rearranged by the user with mouse at any time by dragging the
3333:    * column headers.
3334:    *
3335:    * @param vc the column number (0=first).
3336:    * 
3337:    * @return the table column model index of this column.
3338:    * 
3339:    * @see TableColumn#getModelIndex()
3340:    */
3341:   public int convertColumnIndexToModel(int vc)
3342:   {
3343:     if (vc < 0)
3344:       return vc;
3345:     else
3346:       return columnModel.getColumn(vc).getModelIndex();
3347:   }
3348:   
3349:   /**
3350:    * Convert the table column number to the table column model index.
3351:    * The model number need not match the real column position. The columns
3352:    * may be rearranged by the user with mouse at any time by dragging the
3353:    * column headers.
3354:    *  
3355:    * @param mc the table column index (0=first).
3356:    * 
3357:    * @return the table column number in the model
3358:    * 
3359:    * @see TableColumn#getModelIndex() 
3360:    */
3361:   public int convertColumnIndexToView(int mc)
3362:   {
3363:     if (mc < 0)
3364:       return mc;
3365:     int ncols = getColumnCount();
3366:     for (int vc = 0; vc < ncols; ++vc)
3367:       {
3368:         if (columnModel.getColumn(vc).getModelIndex() == mc)
3369:           return vc;
3370:       }
3371:     return -1;
3372:   }
3373:   
3374:   /**
3375:    * Prepare the renderer for rendering the given cell.
3376:    * 
3377:    * @param renderer the renderer being prepared
3378:    * @param row the row of the cell being rendered
3379:    * @param column the column of the cell being rendered
3380:    * 
3381:    * @return the component which .paint() method will paint the cell.
3382:    */
3383:   public Component prepareRenderer(TableCellRenderer renderer,
3384:                                    int row,
3385:                                    int column)
3386:   {
3387:     boolean rowSelAllowed = getRowSelectionAllowed();
3388:     boolean colSelAllowed = getColumnSelectionAllowed();
3389:     boolean isSel = false;
3390:     if (rowSelAllowed && colSelAllowed || !rowSelAllowed && !colSelAllowed)
3391:       isSel = isCellSelected(row, column);
3392:     else
3393:       isSel = isRowSelected(row) && getRowSelectionAllowed()
3394:            || isColumnSelected(column) && getColumnSelectionAllowed();
3395: 
3396:     // Determine the focused cell. The focused cell is the cell at the
3397:     // leadSelectionIndices of the row and column selection model.
3398:     ListSelectionModel rowSel = getSelectionModel();
3399:     ListSelectionModel colSel = getColumnModel().getSelectionModel();
3400:     boolean hasFocus = hasFocus() && isEnabled()
3401:                        && rowSel.getLeadSelectionIndex() == row
3402:                        && colSel.getLeadSelectionIndex() == column;
3403: 
3404:     return renderer.getTableCellRendererComponent(this,
3405:                                                   dataModel.getValueAt(row, 
3406:                                                convertColumnIndexToModel(column)),
3407:                                                   isSel,
3408:                                                   hasFocus,
3409:                                                   row, column);
3410:   }
3411: 
3412: 
3413:   /**
3414:    * Get the value of the {@link #autoCreateColumnsFromModel} property.
3415:    *
3416:    * @return The current value of the property
3417:    */
3418:   public boolean getAutoCreateColumnsFromModel()
3419:   {
3420:     return autoCreateColumnsFromModel;
3421:   }
3422: 
3423:   /**
3424:    * Get the value of the {@link #autoResizeMode} property.
3425:    *
3426:    * @return The current value of the property
3427:    */
3428:   public int getAutoResizeMode()
3429:   {
3430:     return autoResizeMode;
3431:   }
3432: 
3433:   /**
3434:    * Get the value of the {@link #rowHeight} property.
3435:    *
3436:    * @return The current value of the property
3437:    */
3438:   public int getRowHeight()
3439:   {
3440:     return rowHeight;
3441:   }
3442: 
3443:   /**
3444:    * Get the height of the specified row.
3445:    *
3446:    * @param row the row whose height to return
3447:    */
3448:   public int getRowHeight(int row)
3449:   {
3450:     int rh = rowHeight;
3451:     if (rowHeights != null)
3452:       rh = rowHeights.getSize(row);
3453:     return rh;
3454:   }
3455: 
3456: 
3457:   /**
3458:    * Get the value of the {@link #rowMargin} property.
3459:    *
3460:    * @return The current value of the property
3461:    */
3462:   public int getRowMargin()
3463:   {
3464:     return rowMargin;
3465:   }
3466: 
3467:   /**
3468:    * Get the value of the {@link #rowSelectionAllowed} property.
3469:    *
3470:    * @return The current value of the property
3471:    */
3472:   public boolean getRowSelectionAllowed()
3473:   {
3474:     return rowSelectionAllowed;
3475:   }
3476: 
3477:   /**
3478:    * Get the value of the {@link #cellSelectionEnabled} property.
3479:    *
3480:    * @return The current value of the property
3481:    */
3482:   public boolean getCellSelectionEnabled()
3483:   {
3484:     return getColumnSelectionAllowed() && getRowSelectionAllowed();
3485:   }
3486: 
3487:   /**
3488:    * Get the value of the {@link #dataModel} property.
3489:    *
3490:    * @return The current value of the property
3491:    */
3492:   public TableModel getModel()
3493:   {
3494:     return dataModel;
3495:   }
3496: 
3497:   /**
3498:    * Get the value of the <code>columnCount</code> property by
3499:    * delegation to the {@link #columnModel} field.
3500:    *
3501:    * @return The current value of the columnCount property
3502:    */
3503:   public int getColumnCount()
3504:   {
3505:     return columnModel.getColumnCount();    
3506:   }
3507: 
3508:   /**
3509:    * Get the value of the <code>rowCount</code> property by
3510:    * delegation to the {@link #dataModel} field.
3511:    *
3512:    * @return The current value of the rowCount property
3513:    */
3514:   public int getRowCount()
3515:   {
3516:     return dataModel.getRowCount();
3517:   }
3518: 
3519:   /**
3520:    * Get the value of the {@link #columnModel} property.
3521:    *
3522:    * @return The current value of the property
3523:    */
3524:   public TableColumnModel getColumnModel()
3525:   {
3526:     return columnModel;
3527:   }
3528: 
3529:   /**
3530:    * Get the value of the <code>selectedColumn</code> property by
3531:    * delegation to the {@link #columnModel} field.
3532:    *
3533:    * @return The current value of the selectedColumn property
3534:    */
3535:   public int getSelectedColumn()
3536:   {
3537:     return columnModel.getSelectionModel().getMinSelectionIndex();
3538:   }
3539: 
3540:   private static int countSelections(ListSelectionModel lsm)
3541:   {
3542:     int lo = lsm.getMinSelectionIndex();
3543:     int hi = lsm.getMaxSelectionIndex();
3544:     int sum = 0;
3545:     if (lo != -1 && hi != -1)
3546:       {
3547:         switch (lsm.getSelectionMode())
3548:           {
3549:           case ListSelectionModel.SINGLE_SELECTION:
3550:             sum = 1;
3551:             break;
3552:             
3553:           case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
3554:             sum = hi - lo + 1;
3555:             break;
3556:             
3557:           case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:        
3558:             for (int i = lo; i <= hi; ++i)
3559:               if (lsm.isSelectedIndex(i))        
3560:                 ++sum;
3561:             break;
3562:           }
3563:       }
3564:     return sum;
3565:   }
3566: 
3567:   private static int[] getSelections(ListSelectionModel lsm)
3568:   {
3569:     int sz = countSelections(lsm);
3570:     int [] ret = new int[sz];
3571: 
3572:     int lo = lsm.getMinSelectionIndex();
3573:     int hi = lsm.getMaxSelectionIndex();
3574:     int j = 0;
3575:     if (lo != -1 && hi != -1)
3576:       {
3577:         switch (lsm.getSelectionMode())
3578:           {
3579:           case ListSelectionModel.SINGLE_SELECTION:
3580:             ret[0] = lo;
3581:             break;      
3582:       
3583:           case ListSelectionModel.SINGLE_INTERVAL_SELECTION:            
3584:             for (int i = lo; i <= hi; ++i)
3585:               ret[j++] = i;
3586:             break;
3587:             
3588:           case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:        
3589:             for (int i = lo; i <= hi; ++i)
3590:               if (lsm.isSelectedIndex(i))        
3591:                 ret[j++] = i;
3592:             break;
3593:           }
3594:       }
3595:     return ret;
3596:   }
3597: 
3598:   /**
3599:    * Get the value of the <code>selectedColumnCount</code> property by
3600:    * delegation to the {@link #columnModel} field.
3601:    *
3602:    * @return The current value of the selectedColumnCount property
3603:    */  
3604:   public int getSelectedColumnCount()
3605:   {
3606:     return countSelections(columnModel.getSelectionModel());
3607:   }
3608: 
3609:   /**
3610:    * Get the value of the <code>selectedColumns</code> property by
3611:    * delegation to the {@link #columnModel} field.
3612:    *
3613:    * @return The current value of the selectedColumns property
3614:    */
3615:   public int[] getSelectedColumns()
3616:   {
3617:     return getSelections(columnModel.getSelectionModel());
3618:   }
3619: 
3620:   /**
3621:    * Get the value of the <code>columnSelectionAllowed</code> property.
3622:    *
3623:    * @return The current value of the columnSelectionAllowed property
3624:    */
3625:   public boolean getColumnSelectionAllowed()
3626:   {
3627:     return getColumnModel().getColumnSelectionAllowed();
3628:   }
3629: 
3630:   /**
3631:    * Get the value of the <code>selectedRowCount</code> property by
3632:    * delegation to the {@link #selectionModel} field.
3633:    *
3634:    * @return The current value of the selectedRowCount property
3635:    */
3636:   public int getSelectedRowCount()
3637:   {
3638:     return countSelections(selectionModel);
3639:   }
3640: 
3641:   /**
3642:    * Get the value of the <code>selectedRows</code> property by
3643:    * delegation to the {@link #selectionModel} field.
3644:    *
3645:    * @return The current value of the selectedRows property
3646:    */
3647:   public int[] getSelectedRows()
3648:   {
3649:     return getSelections(selectionModel);
3650:   }
3651: 
3652:   /**
3653:    * Get the value of the {@link #accessibleContext} property.
3654:    *
3655:    * @return The current value of the property
3656:    */
3657:   public AccessibleContext getAccessibleContext()
3658:   {
3659:     if (accessibleContext == null)
3660:       {
3661:         AccessibleJTable ctx = new AccessibleJTable();
3662:         addPropertyChangeListener(ctx);
3663:         TableColumnModel tcm = getColumnModel();
3664:         tcm.addColumnModelListener(ctx);
3665:         tcm.getSelectionModel().addListSelectionListener(ctx);
3666:         getSelectionModel().addListSelectionListener(ctx);
3667:         
3668:         accessibleContext = ctx;
3669:       }
3670:     return accessibleContext;
3671:   }
3672: 
3673:   /**
3674:    * Get the value of the {@link #cellEditor} property.
3675:    *
3676:    * @return The current value of the property
3677:    */
3678:   public TableCellEditor getCellEditor()
3679:   {
3680:     return cellEditor;
3681:   }
3682: 
3683:   /**
3684:    * Get the value of the {@link #dragEnabled} property.
3685:    *
3686:    * @return The current value of the property
3687:    */
3688:   public boolean getDragEnabled()
3689:   {
3690:     return dragEnabled;
3691:   }
3692: 
3693:   /**
3694:    * Get the value of the {@link #gridColor} property.
3695:    *
3696:    * @return The current value of the property
3697:    */
3698:   public Color getGridColor()
3699:   {
3700:     return gridColor;
3701:   }
3702: 
3703:   /**
3704:    * Get the value of the <code>intercellSpacing</code> property.
3705:    *
3706:    * @return The current value of the property
3707:    */
3708:   public Dimension getIntercellSpacing()
3709:   {
3710:     return new Dimension(columnModel.getColumnMargin(), rowMargin);
3711:   }
3712: 
3713:   /**
3714:    * Get the value of the {@link #preferredViewportSize} property.
3715:    *
3716:    * @return The current value of the property
3717:    */
3718:   public Dimension getPreferredScrollableViewportSize()
3719:   {
3720:     return preferredViewportSize;
3721:   }
3722: 
3723:   /**
3724:    * Get the value of the {@link #selectionBackground} property.
3725:    *
3726:    * @return The current value of the property
3727:    */
3728:   public Color getSelectionBackground()
3729:   {
3730:     return selectionBackground;
3731:   }
3732: 
3733:   /**
3734:    * Get the value of the {@link #selectionForeground} property.
3735:    *
3736:    * @return The current value of the property
3737:    */
3738:   public Color getSelectionForeground()
3739:   {
3740:     return selectionForeground;
3741:   }
3742: 
3743:   /**
3744:    * Get the value of the {@link #showHorizontalLines} property.
3745:    *
3746:    * @return The current value of the property
3747:    */
3748:   public boolean getShowHorizontalLines()
3749:   {
3750:     return showHorizontalLines;
3751:   }
3752: 
3753:   /**
3754:    * Get the value of the {@link #showVerticalLines} property.
3755:    *
3756:    * @return The current value of the property
3757:    */
3758:   public boolean getShowVerticalLines()
3759:   {
3760:     return showVerticalLines;
3761:   }
3762: 
3763:   /**
3764:    * Get the value of the {@link #tableHeader} property.
3765:    *
3766:    * @return The current value of the property
3767:    */
3768:   public JTableHeader getTableHeader()
3769:   {
3770:     return tableHeader;
3771:   }
3772: 
3773:   /**
3774:    * Removes specified column from displayable columns of this table.
3775:    *
3776:    * @param column column to removed
3777:    */
3778:   public void removeColumn(TableColumn column)
3779:   {    
3780:     columnModel.removeColumn(column);
3781:   }
3782: 
3783:   /**
3784:    * Moves column at the specified index to new given location.
3785:    *
3786:    * @param column index of the column to move
3787:    * @param targetColumn index specifying new location of the column
3788:    */ 
3789:   public void moveColumn(int column,int targetColumn) 
3790:   {
3791:     columnModel.moveColumn(column, targetColumn);
3792:   }
3793: 
3794:   /**
3795:    * Set the value of the {@link #autoCreateColumnsFromModel} flag.  If the
3796:    * flag changes from <code>false</code> to <code>true</code>, the
3797:    * {@link #createDefaultColumnsFromModel()} method is called.
3798:    *
3799:    * @param autoCreate  the new value of the flag.
3800:    */ 
3801:   public void setAutoCreateColumnsFromModel(boolean autoCreate)
3802:   {
3803:     if (autoCreateColumnsFromModel != autoCreate)
3804:     {
3805:       autoCreateColumnsFromModel = autoCreate;
3806:       if (autoCreate)
3807:         createDefaultColumnsFromModel();
3808:     }
3809:   }
3810: 
3811:   /**
3812:    * Set the value of the {@link #autoResizeMode} property.
3813:    *
3814:    * @param a The new value of the autoResizeMode property
3815:    */ 
3816:   public void setAutoResizeMode(int a)
3817:   {
3818:     autoResizeMode = a;
3819:     revalidate();
3820:     repaint();
3821:   }
3822: 
3823:   /**
3824:    * Sets the height for all rows in the table. If you want to change the
3825:    * height of a single row instead, use {@link #setRowHeight(int, int)}.
3826:    *
3827:    * @param r the height to set for all rows
3828:    *
3829:    * @see #getRowHeight()
3830:    * @see #setRowHeight(int, int)
3831:    * @see #getRowHeight(int)
3832:    */ 
3833:   public void setRowHeight(int r)
3834:   {
3835:     if (r < 1)
3836:       throw new IllegalArgumentException();
3837: 
3838:     clientRowHeightSet = true;
3839: 
3840:     rowHeight = r;
3841:     rowHeights = null;
3842:     revalidate();
3843:     repaint();
3844:   }
3845:   
3846:   /**
3847:    * Sets the height of a single row in the table.
3848:    * 
3849:    * @param rh the new row height
3850:    * @param row the row to change the height of
3851:    */
3852:   public void setRowHeight(int row, int rh)
3853:   {
3854:     if (rowHeights == null)
3855:       {
3856:         rowHeights = new SizeSequence(getRowCount(), rowHeight);
3857:       }
3858:     rowHeights.setSize(row, rh);
3859:   }
3860:   
3861:   /**
3862:    * Set the value of the {@link #rowMargin} property.
3863:    *
3864:    * @param r The new value of the rowMargin property
3865:    */ 
3866:   public void setRowMargin(int r)
3867:   {
3868:     rowMargin = r;
3869:     revalidate();
3870:     repaint();
3871:   }
3872: 
3873:   /**
3874:    * Set the value of the {@link #rowSelectionAllowed} property.
3875:    *
3876:    * @param r The new value of the rowSelectionAllowed property
3877:    */ 
3878:   public void setRowSelectionAllowed(boolean r)
3879:   {
3880:     rowSelectionAllowed = r;
3881:     repaint();
3882:   }
3883: 
3884:   /**
3885:    * Set the value of the {@link #cellSelectionEnabled} property.
3886:    *
3887:    * @param c The new value of the cellSelectionEnabled property
3888:    */ 
3889:   public void setCellSelectionEnabled(boolean c)
3890:   {
3891:     setColumnSelectionAllowed(c);
3892:     setRowSelectionAllowed(c);
3893:     // for backward-compatibility sake:
3894:     cellSelectionEnabled = true;
3895:   }
3896: 
3897:   /**
3898:    * <p>Set the value of the {@link #dataModel} property.</p>
3899:    *
3900:    * <p>Unregister <code>this</code> as a {@link TableModelListener} from
3901:    * previous {@link #dataModel} and register it with new parameter
3902:    * <code>m</code>.</p>
3903:    *
3904:    * @param m The new value of the model property
3905:    */ 
3906:   public void setModel(TableModel m)
3907:   {
3908:     // Throw exception is m is null.
3909:     if (m == null)
3910:       throw new IllegalArgumentException();
3911:    
3912:     // Don't do anything if setting the current model again.
3913:     if (dataModel == m)
3914:       return;
3915: 
3916:     TableModel oldModel = dataModel;
3917: 
3918:     // Remove table as TableModelListener from old model.
3919:     if (dataModel != null)
3920:       dataModel.removeTableModelListener(this);
3921:     
3922:     if (m != null)
3923:       {
3924:         // Set property.
3925:         dataModel = m;
3926: 
3927:         // Add table as TableModelListener to new model.
3928:         dataModel.addTableModelListener(this);
3929: 
3930:         // Notify the tableChanged method.
3931:         tableChanged(new TableModelEvent(dataModel,
3932:                                          TableModelEvent.HEADER_ROW));
3933: 
3934:         // Automatically create columns.
3935:         if (autoCreateColumnsFromModel)
3936:           createDefaultColumnsFromModel();
3937:       }
3938: 
3939:     // This property is bound, so we fire a property change event.
3940:     firePropertyChange("model", oldModel, dataModel);
3941: 
3942:     // Repaint table.
3943:     revalidate();
3944:     repaint();
3945:   }
3946: 
3947:   /**
3948:    * <p>Set the value of the {@link #columnModel} property.</p>
3949:    *
3950:    * <p>Unregister <code>this</code> as a {@link TableColumnModelListener}
3951:    * from previous {@link #columnModel} and register it with new parameter
3952:    * <code>c</code>.</p>
3953:    *
3954:    * @param c The new value of the columnModel property
3955:    */ 
3956:   public void setColumnModel(TableColumnModel c)
3957:   {
3958:     if (c == null)
3959:       throw new IllegalArgumentException();
3960:     TableColumnModel tmp = columnModel;
3961:     if (tmp != null)
3962:       tmp.removeColumnModelListener(this);
3963:     if (c != null)
3964:       c.addColumnModelListener(this);
3965:     columnModel = c;
3966:     if (dataModel != null && columnModel != null)
3967:       {
3968:         int ncols = getColumnCount();
3969:         TableColumn column;
3970:         for (int i = 0; i < ncols; ++i)
3971:           {
3972:             column = columnModel.getColumn(i); 
3973:             if (column.getHeaderValue()==null)
3974:               column.setHeaderValue(dataModel.getColumnName(i));
3975:           }
3976:       }
3977: 
3978:     // according to Sun's spec we also have to set the tableHeader's
3979:     // column model here
3980:     if (tableHeader != null)
3981:       tableHeader.setColumnModel(c);
3982: 
3983:     revalidate();
3984:     repaint();
3985:   }
3986: 
3987:   /**
3988:    * Set the value of the <code>columnSelectionAllowed</code> property.
3989:    *
3990:    * @param c The new value of the property
3991:    */ 
3992:   public void setColumnSelectionAllowed(boolean c)
3993:   {
3994:     getColumnModel().setColumnSelectionAllowed(c);
3995:     repaint();
3996:   }
3997: 
3998:   /**
3999:    * <p>Set the value of the {@link #selectionModel} property.</p>
4000:    *
4001:    * <p>Unregister <code>this</code> as a {@link ListSelectionListener}
4002:    * from previous {@link #selectionModel} and register it with new
4003:    * parameter <code>s</code>.</p>
4004:    *
4005:    * @param s The new value of the selectionModel property
4006:    */ 
4007:   public void setSelectionModel(ListSelectionModel s)
4008:   {
4009:     if (s == null)
4010:       throw new IllegalArgumentException();
4011:     ListSelectionModel tmp = selectionModel;
4012:     if (tmp != null)
4013:       tmp.removeListSelectionListener(this);
4014:     if (s != null)
4015:       s.addListSelectionListener(this);
4016:     selectionModel = s;
4017:   }
4018: 
4019:   /**
4020:    * Set the value of the <code>selectionMode</code> property by
4021:    * delegation to the {@link #selectionModel} field. The same selection
4022:    * mode is set for row and column selection models.
4023:    *
4024:    * @param s The new value of the property
4025:    */ 
4026:   public void setSelectionMode(int s)
4027:   { 
4028:     selectionModel.setSelectionMode(s);    
4029:     columnModel.getSelectionModel().setSelectionMode(s);
4030:     
4031:     repaint();
4032:   }
4033: 
4034:   /**
4035:    * <p>Set the value of the {@link #cellEditor} property.</p>
4036:    *
4037:    * <p>Unregister <code>this</code> as a {@link CellEditorListener} from
4038:    * previous {@link #cellEditor} and register it with new parameter
4039:    * <code>c</code>.</p>
4040:    *
4041:    * @param c The new value of the cellEditor property
4042:    */ 
4043:   public void setCellEditor(TableCellEditor c)
4044:   {
4045:     TableCellEditor tmp = cellEditor;
4046:     if (tmp != null)
4047:       tmp.removeCellEditorListener(this);
4048:     if (c != null)
4049:       c.addCellEditorListener(this);
4050:     cellEditor = c;
4051:   }
4052: 
4053:   /**
4054:    * Set the value of the {@link #dragEnabled} property.
4055:    *
4056:    * @param d The new value of the dragEnabled property
4057:    */ 
4058:   public void setDragEnabled(boolean d)
4059:   {
4060:     dragEnabled = d;
4061:   }
4062: 
4063:   /**
4064:    * Set the value of the {@link #gridColor} property.
4065:    *
4066:    * @param g The new value of the gridColor property
4067:    */ 
4068:   public void setGridColor(Color g)
4069:   {
4070:     gridColor = g;
4071:     repaint();
4072:   }
4073: 
4074:   /**
4075:    * Set the value of the <code>intercellSpacing</code> property.
4076:    *
4077:    * @param i The new value of the intercellSpacing property
4078:    */ 
4079:   public void setIntercellSpacing(Dimension i)
4080:   {
4081:     rowMargin = i.height;
4082:     columnModel.setColumnMargin(i.width);
4083:     repaint();
4084:   }
4085: 
4086:   /**
4087:    * Set the value of the {@link #preferredViewportSize} property.
4088:    *
4089:    * @param p The new value of the preferredViewportSize property
4090:    */ 
4091:   public void setPreferredScrollableViewportSize(Dimension p)
4092:   {
4093:     preferredViewportSize = p;
4094:     revalidate();
4095:     repaint();
4096:   }
4097: 
4098:   /**
4099:    * <p>Set the value of the {@link #selectionBackground} property.</p>
4100:    *
4101:    * <p>Fire a PropertyChangeEvent with name {@link
4102:    * #SELECTION_BACKGROUND_CHANGED_PROPERTY} to registered listeners, if
4103:    * selectionBackground changed.</p>
4104:    *
4105:    * @param s The new value of the selectionBackground property
4106:    */ 
4107:   public void setSelectionBackground(Color s)
4108:   {
4109:     Color tmp = selectionBackground;
4110:     selectionBackground = s;
4111:     if (((tmp == null && s != null)
4112:          || (s == null && tmp != null)
4113:          || (tmp != null && s != null && !tmp.equals(s))))
4114:       firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
4115:     repaint();
4116:   }
4117: 
4118:   /**
4119:    * <p>Set the value of the {@link #selectionForeground} property.</p>
4120:    *
4121:    * <p>Fire a PropertyChangeEvent with name {@link
4122:    * #SELECTION_FOREGROUND_CHANGED_PROPERTY} to registered listeners, if
4123:    * selectionForeground changed.</p>
4124:    *
4125:    * @param s The new value of the selectionForeground property
4126:    */ 
4127:   public void setSelectionForeground(Color s)
4128:   {
4129:     Color tmp = selectionForeground;
4130:     selectionForeground = s;
4131:     if (((tmp == null && s != null)
4132:          || (s == null && tmp != null)
4133:          || (tmp != null && s != null && !tmp.equals(s))))
4134:       firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
4135:     repaint();
4136:   }
4137: 
4138:   /**
4139:    * Set the value of the <code>showGrid</code> property.
4140:    *
4141:    * @param s The new value of the showGrid property
4142:    */ 
4143:   public void setShowGrid(boolean s)
4144:   {
4145:     setShowVerticalLines(s);
4146:     setShowHorizontalLines(s);
4147:   }
4148: 
4149:   /**
4150:    * Set the value of the {@link #showHorizontalLines} property.
4151:    *
4152:    * @param s The new value of the showHorizontalLines property
4153:    */ 
4154:   public void setShowHorizontalLines(boolean s)
4155:   {
4156:     showHorizontalLines = s;
4157:     repaint();
4158:   }
4159: 
4160:   /**
4161:    * Set the value of the {@link #showVerticalLines} property.
4162:    *
4163:    * @param s The new value of the showVerticalLines property
4164:    */ 
4165:   public void setShowVerticalLines(boolean s)
4166:   {
4167:     showVerticalLines = s;
4168:     repaint();
4169:   }
4170: 
4171:   /**
4172:    * Set the value of the {@link #tableHeader} property.
4173:    *
4174:    * @param t The new value of the tableHeader property
4175:    */ 
4176:   public void setTableHeader(JTableHeader t)
4177:   {
4178:     if (tableHeader != null)
4179:       tableHeader.setTable(null);
4180:     tableHeader = t;
4181:     if (tableHeader != null)
4182:       tableHeader.setTable(this);
4183:     revalidate();
4184:     repaint();
4185:   }
4186: 
4187:   protected void configureEnclosingScrollPane()
4188:   {
4189:     JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4190:     if (jsp != null && tableHeader != null)
4191:       {
4192:         jsp.setColumnHeaderView(tableHeader);
4193:       }
4194:   }
4195: 
4196:   protected void unconfigureEnclosingScrollPane()
4197:   {
4198:     JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
4199:     if (jsp != null)
4200:       {
4201:         jsp.setColumnHeaderView(null);
4202:       }    
4203:   }
4204: 
4205: 
4206:   public void addNotify()
4207:   {
4208:     super.addNotify();
4209:     configureEnclosingScrollPane();
4210:   }
4211: 
4212:   public void removeNotify()
4213:   {
4214:     super.addNotify();
4215:     unconfigureEnclosingScrollPane();
4216:   }
4217: 
4218: 
4219:   /**
4220:    * This distributes the superfluous width in a table evenly on its columns.
4221:    *
4222:    * The implementation used here is different to that one described in
4223:    * the JavaDocs. It is much simpler, and seems to work very well.
4224:    *
4225:    * TODO: correctly implement the algorithm described in the JavaDoc
4226:    */
4227:   private void distributeSpill(TableColumn[] cols, int spill)
4228:   {
4229:     int average = spill / cols.length;
4230:     for (int i = 0; i < cols.length; i++)
4231:       {
4232:         if (cols[i] != null)
4233:           cols[i].setWidth(cols[i].getPreferredWidth() + average);
4234:       }
4235:   }
4236:   
4237:   /**
4238:    * This distributes the superfluous width in a table, setting the width of the
4239:    * column being resized strictly to its preferred width.
4240:    */
4241:   private void distributeSpillResizing(TableColumn[] cols, int spill,
4242:                                        TableColumn resizeIt)
4243:   {
4244:     int average = 0;
4245:     if (cols.length != 1)
4246:       average = spill / (cols.length-1);
4247:     for (int i = 0; i < cols.length; i++)
4248:       {
4249:         if (cols[i] != null && !cols[i].equals(resizeIt))
4250:           cols[i].setWidth(cols[i].getPreferredWidth() + average);
4251:       }
4252:     resizeIt.setWidth(resizeIt.getPreferredWidth());
4253:   }  
4254:   
4255:   /**
4256:    * Set the widths of all columns, taking they preferred widths into
4257:    * consideration. The excess space, if any, will be distrubuted between
4258:    * all columns. This method also handles special cases when one of the
4259:    * collumns is currently being resized.
4260:    * 
4261:    * @see TableColumn#setPreferredWidth(int)
4262:    */
4263:   public void doLayout()
4264:   {
4265:     TableColumn resizingColumn = null;
4266:     
4267:     int ncols = getColumnCount();
4268:     if (ncols < 1)
4269:       return;
4270: 
4271:     int prefSum = 0;
4272:     int rCol = -1;
4273: 
4274:     if (tableHeader != null)
4275:       resizingColumn = tableHeader.getResizingColumn();
4276: 
4277:     for (int i = 0; i < ncols; ++i)
4278:       {
4279:         TableColumn col = columnModel.getColumn(i);
4280:         int p = col.getPreferredWidth();
4281:         prefSum += p;
4282:         if (resizingColumn == col)
4283:           rCol = i;
4284:       }
4285: 
4286:     int spill = getWidth() - prefSum;
4287: 
4288:     if (resizingColumn != null)
4289:       {
4290:         TableColumn col;
4291:         TableColumn [] cols;
4292:         
4293:         switch (getAutoResizeMode())
4294:           {
4295:           case AUTO_RESIZE_LAST_COLUMN:
4296:             col = columnModel.getColumn(ncols-1);
4297:             col.setWidth(col.getPreferredWidth() + spill);
4298:             break;
4299:             
4300:           case AUTO_RESIZE_NEXT_COLUMN:
4301:             col = columnModel.getColumn(ncols-1);
4302:             col.setWidth(col.getPreferredWidth() + spill);
4303:             break;
4304: 
4305:           case AUTO_RESIZE_ALL_COLUMNS:
4306:             cols = new TableColumn[ncols];
4307:             for (int i = 0; i < ncols; ++i)
4308:               cols[i] = columnModel.getColumn(i);
4309:             distributeSpillResizing(cols, spill, resizingColumn);
4310:             break;
4311: 
4312:           case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
4313:             
4314:             // Subtract the width of the non-resized columns from the spill.
4315:             int w = 0;
4316:             int wp = 0;
4317:             TableColumn column;
4318:             for (int i = 0; i < rCol; i++)
4319:               {
4320:                 column = columnModel.getColumn(i);
4321:                 w += column.getWidth();
4322:                 wp+= column.getPreferredWidth();
4323:               }
4324: 
4325:             // The number of columns right from the column being resized.
4326:             int n = ncols-rCol-1;
4327:             if (n>0)
4328:               {
4329:                 // If there are any columns on the right sied to resize.
4330:                 spill = (getWidth()-w) - (prefSum-wp);
4331:                 int average = spill / n;
4332:             
4333:                  // For all columns right from the column being resized:
4334:                 for (int i = rCol+1; i < ncols; i++)
4335:                   {
4336:                     column = columnModel.getColumn(i);
4337:                     column.setWidth(column.getPreferredWidth() + average);
4338:                   }
4339:               }
4340:             resizingColumn.setWidth(resizingColumn.getPreferredWidth());
4341:             break;
4342: 
4343:           case AUTO_RESIZE_OFF:
4344:           default:
4345:             int prefWidth = resizingColumn.getPreferredWidth();
4346:             resizingColumn.setWidth(prefWidth);
4347:           }
4348:       }
4349:     else
4350:       {
4351:         TableColumn [] cols = new TableColumn[ncols];
4352:         for (int i = 0; i < ncols; ++i)
4353:           cols[i] = columnModel.getColumn(i);
4354:         distributeSpill(cols, spill);
4355:       }
4356:     
4357:     if (editorComp!=null)
4358:       moveToCellBeingEdited(editorComp);
4359:     
4360:     int leftBoundary = getLeftResizingBoundary();
4361:     int width = getWidth() - leftBoundary;
4362:     repaint(leftBoundary, 0, width, getHeight());
4363:     if (tableHeader != null)
4364:       tableHeader.repaint(leftBoundary, 0, width, tableHeader.getHeight());
4365:   }
4366:   
4367:   /**
4368:    * Get the left boundary of the rectangle which changes during the column
4369:    * resizing.
4370:    */
4371:   int getLeftResizingBoundary()
4372:   {
4373:     if (tableHeader == null || getAutoResizeMode() == AUTO_RESIZE_ALL_COLUMNS)
4374:       return 0;
4375:     else
4376:       {
4377:         TableColumn resizingColumn = tableHeader.getResizingColumn();
4378:         if (resizingColumn == null)
4379:           return 0;
4380: 
4381:         int rc = convertColumnIndexToView(resizingColumn.getModelIndex());
4382:         int p = 0;
4383: 
4384:         for (int i = 0; i < rc; i++)
4385:           p += columnModel.getColumn(i).getWidth();
4386:         
4387:         return p;
4388:       }
4389:   }
4390:   
4391:   
4392:   /**
4393:    * @deprecated Replaced by <code>doLayout()</code>
4394:    */
4395:   public void sizeColumnsToFit(boolean lastColumnOnly)
4396:   {
4397:     doLayout();
4398:   }
4399:   
4400:   /**
4401:    * Obsolete since JDK 1.4. Please use <code>doLayout()</code>.
4402:    */
4403:   public void sizeColumnsToFit(int resizingColumn)
4404:   {
4405:     doLayout();
4406:   }
4407: 
4408:   public String getUIClassID()
4409:   {
4410:     return "TableUI";
4411:   }
4412: 
4413:   /**
4414:    * This method returns the table's UI delegate.
4415:    *
4416:    * @return The table's UI delegate.
4417:    */
4418:   public TableUI getUI()
4419:   {
4420:     return (TableUI) ui;
4421:   }
4422: 
4423:   /**
4424:    * This method sets the table's UI delegate.
4425:    *
4426:    * @param ui The table's UI delegate.
4427:    */
4428:   public void setUI(TableUI ui)
4429:   {
4430:     super.setUI(ui);
4431:     // The editors and renderers must be recreated because they constructors
4432:     // may use the look and feel properties.
4433:     createDefaultEditors();
4434:     createDefaultRenderers();
4435:   }
4436: 
4437:   public void updateUI()
4438:   {
4439:     setUI((TableUI) UIManager.getUI(this));
4440:   }
4441:   
4442:   /**
4443:    * Get the class (datatype) of the column. The cells are rendered and edited
4444:    * differently, depending from they data type.
4445:    * 
4446:    * @param column the column (not the model index).
4447:    * 
4448:    * @return the class, defining data type of that column (String.class for
4449:    * String, Boolean.class for boolean and so on).
4450:    */
4451:   public Class getColumnClass(int column)
4452:   {
4453:     return getModel().getColumnClass(convertColumnIndexToModel(column));
4454:   }
4455:   
4456:   /**
4457:    * Get the name of the column. If the column has the column identifier set,
4458:    * the return value is the result of the .toString() method call on that
4459:    * identifier. If the identifier is not explicitly set, the returned value
4460:    * is calculated by 
4461:    * {@link javax.swing.table.AbstractTableModel#getColumnName(int)}.
4462:    * 
4463:    * @param column the column
4464:    * 
4465:    * @return the name of that column.
4466:    */
4467:   public String getColumnName(int column)
4468:   {
4469:     int modelColumn = columnModel.getColumn(column).getModelIndex();
4470:     return dataModel.getColumnName(modelColumn);
4471:   }
4472:   
4473:   /**
4474:    * Get the column, currently being edited
4475:    * 
4476:    * @return the column, currently being edited.
4477:    */
4478:   public int getEditingColumn()
4479:   {
4480:     return editingColumn;
4481:   }
4482:   
4483:   /**
4484:    * Set the column, currently being edited
4485:    * 
4486:    * @param column the column, currently being edited.
4487:    */
4488:   public void setEditingColumn(int column)
4489:   {
4490:     editingColumn = column;
4491:   }
4492:   
4493:   /**
4494:    * Get the row currently being edited.
4495:    * 
4496:    * @return the row, currently being edited.
4497:    */
4498:   public int getEditingRow()
4499:   {
4500:     return editingRow;
4501:   }
4502:   
4503:   /**
4504:    * Set the row currently being edited.
4505:    * 
4506:    * @param row the row, that will be edited
4507:    */
4508:   public void setEditingRow(int row)
4509:   {
4510:     editingRow = row;
4511:   }
4512:   
4513:   /**
4514:    * Get the editor component that is currently editing one of the cells
4515:    * 
4516:    * @return the editor component or null, if none of the cells is being
4517:    * edited.
4518:    */
4519:   public Component getEditorComponent()
4520:   {
4521:     return editorComp;
4522:   }
4523:   
4524:   /**
4525:    * Check if one of the table cells is currently being edited.
4526:    * 
4527:    * @return true if there is a cell being edited.
4528:    */
4529:   public boolean isEditing()
4530:   {
4531:     return editorComp != null;
4532:   }
4533:   
4534:   /**
4535:    * Set the default editor for the given column class (column data type).
4536:    * By default, String is handled by text field and Boolean is handled by
4537:    * the check box.
4538:    *  
4539:    * @param columnClass the column data type
4540:    * @param editor the editor that will edit this data type
4541:    * 
4542:    * @see TableModel#getColumnClass(int)
4543:    */
4544:   public void setDefaultEditor(Class columnClass, TableCellEditor editor)
4545:   {
4546:     if (editor != null)
4547:       defaultEditorsByColumnClass.put(columnClass, editor);
4548:     else
4549:       defaultEditorsByColumnClass.remove(columnClass);
4550:   }
4551:   
4552:   public void addColumnSelectionInterval(int index0, int index1)
4553:   {
4554:     if ((index0 < 0 || index0 > (getColumnCount()-1)
4555:          || index1 < 0 || index1 > (getColumnCount()-1)))
4556:       throw new IllegalArgumentException("Column index out of range.");
4557:     
4558:     getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
4559:   }
4560:   
4561:   public void addRowSelectionInterval(int index0, int index1)
4562:   {            
4563:     if ((index0 < 0 || index0 > (getRowCount()-1)
4564:          || index1 < 0 || index1 > (getRowCount()-1)))
4565:       throw new IllegalArgumentException("Row index out of range.");
4566:           
4567:     getSelectionModel().addSelectionInterval(index0, index1);
4568:   }
4569:   
4570:   public void setColumnSelectionInterval(int index0, int index1)
4571:   {
4572:     if ((index0 < 0 || index0 > (getColumnCount()-1)
4573:          || index1 < 0 || index1 > (getColumnCount()-1)))
4574:       throw new IllegalArgumentException("Column index out of range.");
4575: 
4576:     getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
4577:   }
4578:   
4579:   public void setRowSelectionInterval(int index0, int index1)
4580:   {    
4581:     if ((index0 < 0 || index0 > (getRowCount()-1)
4582:          || index1 < 0 || index1 > (getRowCount()-1)))
4583:       throw new IllegalArgumentException("Row index out of range.");
4584: 
4585:     getSelectionModel().setSelectionInterval(index0, index1);
4586:   }
4587:   
4588:   public void removeColumnSelectionInterval(int index0, int index1)  
4589:   {
4590:     if ((index0 < 0 || index0 > (getColumnCount()-1)
4591:          || index1 < 0 || index1 > (getColumnCount()-1)))
4592:       throw new IllegalArgumentException("Column index out of range.");
4593: 
4594:     getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
4595:   }
4596:   
4597:   public void removeRowSelectionInterval(int index0, int index1)
4598:   {
4599:     if ((index0 < 0 || index0 > (getRowCount()-1)
4600:          || index1 < 0 || index1 > (getRowCount()-1)))
4601:       throw new IllegalArgumentException("Row index out of range.");
4602: 
4603:     getSelectionModel().removeSelectionInterval(index0, index1);
4604:   }
4605:   
4606:   /**
4607:    * Checks if the given column is selected.
4608:    * 
4609:    * @param column the column
4610:    * 
4611:    * @return true if the column is selected (as reported by the selection
4612:    * model, associated with the column model), false otherwise.
4613:    */
4614:   public boolean isColumnSelected(int column)
4615:   {
4616:     return getColumnModel().getSelectionModel().isSelectedIndex(column);
4617:   }
4618:   
4619:   /**
4620:    * Checks if the given row is selected.
4621:    * 
4622:    * @param row the row
4623:    * 
4624:    * @return true if the row is selected (as reported by the selection model),
4625:    * false otherwise.
4626:    */
4627:   public boolean isRowSelected(int row)
4628:   {
4629:     return getSelectionModel().isSelectedIndex(row);
4630:   }
4631:   
4632:   /**
4633:    * Checks if the given cell is selected. The cell is selected if both
4634:    * the cell row and the cell column are selected.
4635:    * 
4636:    * @param row the cell row
4637:    * @param column the cell column
4638:    * 
4639:    * @return true if the cell is selected, false otherwise
4640:    */
4641:   public boolean isCellSelected(int row, int column)
4642:   {
4643:     return isRowSelected(row) && isColumnSelected(column);
4644:   }
4645:   
4646:   /**
4647:    * Select all table.
4648:    */
4649:   public void selectAll()
4650:   {
4651:     // The table is empty - nothing to do!
4652:     if (getRowCount() == 0 || getColumnCount() == 0)
4653:       return;
4654:     
4655:     // rowLead and colLead store the current lead selection indices
4656:     int rowLead = selectionModel.getLeadSelectionIndex();
4657:     int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
4658:     // the following calls to setSelectionInterval change the lead selection
4659:     // indices
4660:     setColumnSelectionInterval(0, getColumnCount() - 1);
4661:     setRowSelectionInterval(0, getRowCount() - 1);
4662:     // the following addSelectionInterval calls restore the lead selection
4663:     // indices to their previous values
4664:     addColumnSelectionInterval(colLead,colLead);
4665:     addRowSelectionInterval(rowLead, rowLead);
4666:   }
4667:   
4668:   /**
4669:    * Get the cell value at the given position.
4670:    * 
4671:    * @param row the row to get the value
4672:    * @param column the actual column number (not the model index) 
4673:    * to get the value.
4674:    * 
4675:    * @return the cell value, as returned by model.
4676:    */
4677:   public Object getValueAt(int row, int column)
4678:   {
4679:     return dataModel.getValueAt(row, convertColumnIndexToModel(column));
4680:   }
4681:   
4682:   /**
4683:    * Set value for the cell at the given position. The modified cell is
4684:    * repainted.
4685:    * 
4686:    * @param value the value to set
4687:    * @param row the row of the cell being modified
4688:    * @param column the column of the cell being modified
4689:    */
4690:   public void setValueAt(Object value, int row, int column)
4691:   {
4692:     dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
4693:     
4694:     repaint(getCellRect(row, column, true));
4695:   }
4696:   
4697:   /**
4698:    * Get table column with the given identified.
4699:    * 
4700:    * @param identifier the column identifier
4701:    * 
4702:    * @return the table column with this identifier
4703:    * 
4704:    * @throws IllegalArgumentException if <code>identifier</code> is 
4705:    *         <code>null</code> or there is no column with that identifier.
4706:    * 
4707:    * @see TableColumn#setIdentifier(Object)
4708:    */
4709:   public TableColumn getColumn(Object identifier)
4710:   {
4711:     return columnModel.getColumn(columnModel.getColumnIndex(identifier));
4712:   }
4713: 
4714:   /**
4715:    * Returns <code>true</code> if the specified cell is editable, and
4716:    * <code>false</code> otherwise.
4717:    *
4718:    * @param row  the row index.
4719:    * @param column  the column index.
4720:    *
4721:    * @return true if the cell is editable, false otherwise.
4722:    */
4723:   public boolean isCellEditable(int row, int column)
4724:   {
4725:     return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
4726:   }
4727: 
4728:   /**
4729:    * Clears any existing columns from the <code>JTable</code>'s
4730:    * {@link TableColumnModel} and creates new columns to match the values in
4731:    * the data ({@link TableModel}) used by the table.
4732:    *
4733:    * @see #setAutoCreateColumnsFromModel(boolean)
4734:    */
4735:   public void createDefaultColumnsFromModel()
4736:   {
4737:     assert columnModel != null : "The columnModel must not be null.";
4738: 
4739:     // remove existing columns
4740:     int columnIndex = columnModel.getColumnCount() - 1;
4741:     while (columnIndex >= 0)
4742:     {
4743:       columnModel.removeColumn(columnModel.getColumn(columnIndex));
4744:       columnIndex--;
4745:     }
4746:   
4747:     // add new columns to match the TableModel
4748:     int columnCount = dataModel.getColumnCount();
4749:     for (int c = 0; c < columnCount; c++)
4750:     {
4751:       TableColumn column = new TableColumn(c);
4752:       column.setIdentifier(dataModel.getColumnName(c));
4753:       column.setHeaderValue(dataModel.getColumnName(c));
4754:       columnModel.addColumn(column);
4755:       column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
4756:     }
4757:   }
4758: 
4759:   public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
4760:   {
4761:     if (toggle && extend)
4762:       {
4763:         // Leave the selection state as is, but move the anchor
4764:         //   index to the specified location
4765:         selectionModel.setAnchorSelectionIndex(rowIndex);
4766:         getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
4767:       }
4768:     else if (toggle)
4769:       {
4770:         // Toggle the state of the specified cell
4771:         if (isCellSelected(rowIndex,columnIndex))
4772:           {
4773:             selectionModel.removeSelectionInterval(rowIndex,rowIndex);
4774:             getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
4775:           }
4776:         else
4777:           {
4778:             selectionModel.addSelectionInterval(rowIndex,rowIndex);
4779:             getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
4780:           }
4781:       }
4782:     else if (extend)
4783:       {
4784:         // Extend the previous selection from the anchor to the 
4785:         // specified cell, clearing all other selections
4786:         selectionModel.setLeadSelectionIndex(rowIndex);
4787:         getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
4788:       }
4789:     else
4790:       {
4791:         // Clear the previous selection and ensure the new cell
4792:         // is selected
4793:          selectionModel.clearSelection();
4794:         selectionModel.setSelectionInterval(rowIndex,rowIndex);
4795:         getColumnModel().getSelectionModel().clearSelection();
4796:         getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
4797:         
4798:         
4799:       }
4800:   }
4801: 
4802:   /**
4803:    * Programmatically starts editing the specified cell.
4804:    * 
4805:    * @param row the row of the cell to edit.
4806:    * @param column the column of the cell to edit.
4807:    */
4808:   public boolean editCellAt(int row, int column)
4809:   {
4810:     // Complete the previous editing session, if still active.
4811:     if (isEditing())
4812:       editingStopped(new ChangeEvent("editingStopped"));
4813: 
4814:     TableCellEditor editor = getCellEditor(row, column);
4815:     
4816:     // The boolean values are inverted by the single click without the
4817:     // real editing session.
4818:     if (editor == booleanInvertingEditor && isCellEditable(row, column))
4819:       {
4820:         if (Boolean.TRUE.equals(getValueAt(row, column)))
4821:           setValueAt(Boolean.FALSE, row, column);
4822:         else
4823:           setValueAt(Boolean.TRUE, row, column);
4824:         return false;
4825:       }
4826:     else
4827:       {
4828:         editingRow = row;
4829:         editingColumn = column;
4830: 
4831:         setCellEditor(editor);
4832:         editorComp = prepareEditor(cellEditor, row, column);
4833: 
4834:         // Remove the previous editor components, if present. Only one
4835:         // editor component at time is allowed in the table.
4836:         removeAll();
4837:         add(editorComp);
4838:         moveToCellBeingEdited(editorComp);
4839:         scrollRectToVisible(editorComp.getBounds());
4840:         editorComp.requestFocusInWindow();
4841:         
4842:         // Deliver the should select event.
4843:         return editor.shouldSelectCell(null);        
4844:       }
4845:   }
4846: 
4847:   /**
4848:    * Move the given component under the cell being edited. 
4849:    * The table must be in the editing mode.
4850:    * 
4851:    * @param component the component to move.
4852:    */
4853:   private void moveToCellBeingEdited(Component component)
4854:   {
4855:      Rectangle r = getCellRect(editingRow, editingColumn, true);
4856:      // Adjust bounding box of the editing component, so that it lies
4857:      // 'above' the grid on all edges, not only right and bottom.
4858:      // The table grid is painted only at the right and bottom edge of a cell.
4859:      r.x -= 1;
4860:      r.y -= 1;
4861:      r.width += 1;
4862:      r.height += 1;
4863:      component.setBounds(r);
4864:   }
4865: 
4866:   /**
4867:    * Programmatically starts editing the specified cell.
4868:    *
4869:    * @param row the row of the cell to edit.
4870:    * @param column the column of the cell to edit.
4871:    */
4872:   public boolean editCellAt (int row, int column, EventObject e)
4873:   {
4874:     return editCellAt(row, column);
4875:   }
4876: 
4877:   /**
4878:    * Discards the editor object.
4879:    */
4880:   public void removeEditor()
4881:   {
4882:     editingStopped(new ChangeEvent(this));
4883:   }
4884: 
4885:   /**
4886:    * Prepares the editor by querying for the value and selection state of the
4887:    * cell at (row, column).
4888:    *
4889:    * @param editor the TableCellEditor to set up
4890:    * @param row the row of the cell to edit
4891:    * @param column the column of the cell to edit
4892:    * @return the Component being edited
4893:    */
4894:   public Component prepareEditor (TableCellEditor editor, int row, int column)
4895:   {
4896:     return editor.getTableCellEditorComponent
4897:       (this, getValueAt(row, column), isCellSelected(row, column), row, column);
4898:   }
4899: 
4900:   /**
4901:    * This revalidates the <code>JTable</code> and queues a repaint.
4902:    */
4903:   protected void resizeAndRepaint()
4904:   {
4905:     revalidate();
4906:     repaint();
4907:   }
4908: 
4909:   /**
4910:    * Sets whether cell editors of this table should receive keyboard focus
4911:    * when the editor is activated by a keystroke. The default setting is
4912:    * <code>false</code> which means that the table should keep the keyboard
4913:    * focus until the cell is selected by a mouse click.
4914:    *
4915:    * @param value the value to set
4916:    *
4917:    * @since 1.4
4918:    */
4919:   public void setSurrendersFocusOnKeystroke(boolean value)
4920:   {
4921:     // TODO: Implement functionality of this property (in UI impl).
4922:     surrendersFocusOnKeystroke = value;
4923:   }
4924:   
4925:   /**
4926:    * Returns whether cell editors of this table should receive keyboard focus
4927:    * when the editor is activated by a keystroke. The default setting is
4928:    * <code>false</code> which means that the table should keep the keyboard
4929:    * focus until the cell is selected by a mouse click.
4930:    *
4931:    * @return whether cell editors of this table should receive keyboard focus
4932:    *         when the editor is activated by a keystroke
4933:    *
4934:    * @since 1.4
4935:    */
4936:   public boolean getSurrendersFocusOnKeystroke()
4937:   {
4938:     // TODO: Implement functionality of this property (in UI impl).
4939:     return surrendersFocusOnKeystroke;
4940:   }
4941: 
4942:   /**
4943:    * Helper method for
4944:    * {@link LookAndFeel#installProperty(JComponent, String, Object)}.
4945:    * 
4946:    * @param propertyName the name of the property
4947:    * @param value the value of the property
4948:    *
4949:    * @throws IllegalArgumentException if the specified property cannot be set
4950:    *         by this method
4951:    * @throws ClassCastException if the property value does not match the
4952:    *         property type
4953:    * @throws NullPointerException if <code>c</code> or
4954:    *         <code>propertyValue</code> is <code>null</code>
4955:    */
4956:   void setUIProperty(String propertyName, Object value)
4957:   {
4958:     if (propertyName.equals("rowHeight"))
4959:       {
4960:         if (! clientRowHeightSet)
4961:           {
4962:             setRowHeight(((Integer) value).intValue());
4963:             clientRowHeightSet = false;
4964:           }
4965:       }
4966:     else
4967:       {
4968:         super.setUIProperty(propertyName, value);
4969:       }
4970:   }
4971: }