Source for javax.swing.plaf.basic.BasicTableUI

   1: /* BasicTableUI.java --
   2:    Copyright (C) 2004 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 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.plaf.basic;
  40: 
  41: import java.awt.Color;
  42: import java.awt.Component;
  43: import java.awt.ComponentOrientation;
  44: import java.awt.Dimension;
  45: import java.awt.Graphics;
  46: import java.awt.Point;
  47: import java.awt.Rectangle;
  48: import java.awt.event.ActionEvent;
  49: import java.awt.event.FocusEvent;
  50: import java.awt.event.FocusListener;
  51: import java.awt.event.KeyEvent;
  52: import java.awt.event.KeyListener;
  53: import java.awt.event.MouseEvent;
  54: import java.beans.PropertyChangeEvent;
  55: import java.beans.PropertyChangeListener;
  56: 
  57: import javax.swing.AbstractAction;
  58: import javax.swing.Action;
  59: import javax.swing.ActionMap;
  60: import javax.swing.CellRendererPane;
  61: import javax.swing.DefaultCellEditor;
  62: import javax.swing.DefaultListSelectionModel;
  63: import javax.swing.InputMap;
  64: import javax.swing.JComponent;
  65: import javax.swing.JTable;
  66: import javax.swing.ListSelectionModel;
  67: import javax.swing.LookAndFeel;
  68: import javax.swing.SwingUtilities;
  69: import javax.swing.TransferHandler;
  70: import javax.swing.UIManager;
  71: import javax.swing.border.Border;
  72: import javax.swing.event.ChangeEvent;
  73: import javax.swing.event.MouseInputListener;
  74: import javax.swing.plaf.ActionMapUIResource;
  75: import javax.swing.plaf.ComponentUI;
  76: import javax.swing.plaf.TableUI;
  77: import javax.swing.table.TableCellEditor;
  78: import javax.swing.table.TableCellRenderer;
  79: import javax.swing.table.TableColumn;
  80: import javax.swing.table.TableColumnModel;
  81: import javax.swing.table.TableModel;
  82: 
  83: public class BasicTableUI extends TableUI
  84: {
  85:   public static ComponentUI createUI(JComponent comp) 
  86:   {
  87:     return new BasicTableUI();
  88:   }
  89: 
  90:   protected FocusListener focusListener;  
  91:   protected KeyListener keyListener;   
  92:   protected MouseInputListener  mouseInputListener;   
  93:   protected CellRendererPane rendererPane;   
  94:   protected JTable table;
  95: 
  96:   /** The normal cell border. */
  97:   Border cellBorder;
  98: 
  99:   /** The action bound to KeyStrokes. */
 100:   TableAction action;
 101: 
 102:   /**
 103:    * Listens for changes to the tables properties.
 104:    */
 105:   private PropertyChangeListener propertyChangeListener;
 106: 
 107:   /**
 108:    * Handles key events for the JTable. Key events should be handled through
 109:    * the InputMap/ActionMap mechanism since JDK1.3. This class is only there
 110:    * for backwards compatibility.
 111:    * 
 112:    * @author Roman Kennke (kennke@aicas.com)
 113:    */
 114:   public class KeyHandler implements KeyListener
 115:   {
 116: 
 117:     /**
 118:      * Receives notification that a key has been pressed and released.
 119:      * Activates the editing session for the focused cell by pressing the
 120:      * character keys.
 121:      *
 122:      * @param event the key event
 123:      */
 124:     public void keyTyped(KeyEvent event)
 125:     {
 126:       // Key events should be handled through the InputMap/ActionMap mechanism
 127:       // since JDK1.3. This class is only there for backwards compatibility.
 128:       
 129:       // Editor activation is a specific kind of response to ''any''
 130:       // character key. Hence it is handled here.
 131:       if (!table.isEditing() && table.isEnabled())
 132:         {
 133:           int r = table.getSelectedRow();
 134:           int c = table.getSelectedColumn();
 135:           if (table.isCellEditable(r, c))
 136:             table.editCellAt(r, c);
 137:         }
 138:     }
 139: 
 140:     /**
 141:      * Receives notification that a key has been pressed.
 142:      *
 143:      * @param event the key event
 144:      */
 145:     public void keyPressed(KeyEvent event)
 146:     {
 147:       // Key events should be handled through the InputMap/ActionMap mechanism
 148:       // since JDK1.3. This class is only there for backwards compatibility.
 149:     }
 150: 
 151:     /**
 152:      * Receives notification that a key has been released.
 153:      *
 154:      * @param event the key event
 155:      */
 156:     public void keyReleased(KeyEvent event)
 157:     {
 158:       // Key events should be handled through the InputMap/ActionMap mechanism
 159:       // since JDK1.3. This class is only there for backwards compatibility.
 160:     }
 161:   }
 162: 
 163:   public class FocusHandler implements FocusListener
 164:   {
 165:     public void focusGained(FocusEvent e)
 166:     {
 167:       // The only thing that is affected by a focus change seems to be
 168:       // how the lead cell is painted. So we repaint this cell.
 169:       repaintLeadCell();
 170:     }
 171: 
 172:     public void focusLost(FocusEvent e)
 173:     {
 174:       // The only thing that is affected by a focus change seems to be
 175:       // how the lead cell is painted. So we repaint this cell.
 176:       repaintLeadCell();
 177:     }
 178: 
 179:     /**
 180:      * Repaints the lead cell in response to a focus change, to refresh
 181:      * the display of the focus indicator.
 182:      */
 183:     private void repaintLeadCell()
 184:     {
 185:       int rowCount = table.getRowCount();
 186:       int columnCount = table.getColumnCount();
 187:       int rowLead = table.getSelectionModel().getLeadSelectionIndex();
 188:       int columnLead = table.getColumnModel().getSelectionModel().
 189:                                                        getLeadSelectionIndex();
 190:       if (rowLead >= 0 && rowLead < rowCount && columnLead >= 0
 191:           && columnLead < columnCount)
 192:         {
 193:           Rectangle dirtyRect = table.getCellRect(rowLead, columnLead, false);
 194:           table.repaint(dirtyRect);
 195:         }
 196:     }
 197:   }
 198: 
 199:   public class MouseInputHandler implements MouseInputListener
 200:   {
 201:     Point begin, curr;
 202: 
 203:     private void updateSelection(boolean controlPressed)
 204:     {
 205:       // Update the rows
 206:       int lo_row = table.rowAtPoint(begin);
 207:       int hi_row  = table.rowAtPoint(curr);
 208:       ListSelectionModel rowModel = table.getSelectionModel();
 209:       if (lo_row != -1 && hi_row != -1)
 210:         {
 211:           if (controlPressed && rowModel.getSelectionMode() 
 212:               != ListSelectionModel.SINGLE_SELECTION)
 213:             rowModel.addSelectionInterval(lo_row, hi_row);
 214:           else
 215:             rowModel.setSelectionInterval(lo_row, hi_row);
 216:         }
 217:       
 218:       // Update the columns
 219:       int lo_col = table.columnAtPoint(begin);
 220:       int hi_col = table.columnAtPoint(curr);
 221:       ListSelectionModel colModel = table.getColumnModel().
 222:         getSelectionModel();
 223:       if (lo_col != -1 && hi_col != -1)
 224:         {
 225:           if (controlPressed && colModel.getSelectionMode() != 
 226:               ListSelectionModel.SINGLE_SELECTION)
 227:             colModel.addSelectionInterval(lo_col, hi_col);
 228:           else
 229:             colModel.setSelectionInterval(lo_col, hi_col);
 230:         }
 231:     }
 232:     
 233:     /**
 234:      * For the double click, start the cell editor.
 235:      */
 236:     public void mouseClicked(MouseEvent e)
 237:     {
 238:       Point p = e.getPoint();
 239:       int row = table.rowAtPoint(p);
 240:       int col = table.columnAtPoint(p);
 241:       if (table.isCellEditable(row, col))
 242:         {
 243:           // If the cell editor is the default editor, we request the
 244:           // number of the required clicks from it. Otherwise,
 245:           // require two clicks (double click).
 246:           TableCellEditor editor = table.getCellEditor(row, col);
 247:           if (editor instanceof DefaultCellEditor)
 248:             {
 249:               DefaultCellEditor ce = (DefaultCellEditor) editor;
 250:               if (e.getClickCount() < ce.getClickCountToStart())
 251:                 return;
 252:             }
 253:           table.editCellAt(row, col);
 254:         }
 255:     }
 256: 
 257:     public void mouseDragged(MouseEvent e) 
 258:     {
 259:       if (table.isEnabled())
 260:         {
 261:           curr = new Point(e.getX(), e.getY());
 262:           updateSelection(e.isControlDown());
 263:         }
 264:     }
 265: 
 266:     public void mouseEntered(MouseEvent e)
 267:     {
 268:       // Nothing to do here.
 269:     }
 270: 
 271:     public void mouseExited(MouseEvent e)
 272:     {
 273:       // Nothing to do here.
 274:     }
 275: 
 276:     public void mouseMoved(MouseEvent e)
 277:     {
 278:       // Nothing to do here.
 279:     }
 280: 
 281:     public void mousePressed(MouseEvent e) 
 282:     {
 283:       if (table.isEnabled())
 284:         {
 285:           ListSelectionModel rowModel = table.getSelectionModel();
 286:           ListSelectionModel colModel = table.getColumnModel().getSelectionModel();
 287:           int rowLead = rowModel.getLeadSelectionIndex();
 288:           int colLead = colModel.getLeadSelectionIndex();
 289: 
 290:           begin = new Point(e.getX(), e.getY());
 291:           curr = new Point(e.getX(), e.getY());
 292:           //if control is pressed and the cell is already selected, deselect it
 293:           if (e.isControlDown() && table.isCellSelected(
 294:               table.rowAtPoint(begin), table.columnAtPoint(begin)))
 295:             {                                       
 296:               table.getSelectionModel().
 297:               removeSelectionInterval(table.rowAtPoint(begin), 
 298:                                       table.rowAtPoint(begin));
 299:               table.getColumnModel().getSelectionModel().
 300:               removeSelectionInterval(table.columnAtPoint(begin), 
 301:                                       table.columnAtPoint(begin));
 302:             }
 303:           else
 304:             updateSelection(e.isControlDown());
 305: 
 306:           // If we were editing, but the moved to another cell, stop editing
 307:           if (rowLead != rowModel.getLeadSelectionIndex() ||
 308:               colLead != colModel.getLeadSelectionIndex())
 309:             if (table.isEditing())
 310:               table.editingStopped(new ChangeEvent(e));
 311: 
 312:           // Must request focus explicitly.
 313:           table.requestFocusInWindow();
 314:         }
 315:     }
 316: 
 317:     public void mouseReleased(MouseEvent e) 
 318:     {
 319:       if (table.isEnabled())
 320:         {
 321:           begin = null;
 322:           curr = null;
 323:         }
 324:     }
 325:   }
 326: 
 327:   /**
 328:    * Listens for changes to the model property of the JTable and adjusts some
 329:    * settings.
 330:    *
 331:    * @author Roman Kennke (kennke@aicas.com)
 332:    */
 333:   private class PropertyChangeHandler implements PropertyChangeListener
 334:   {
 335:     /**
 336:      * Receives notification if one of the JTable's properties changes.
 337:      *
 338:      * @param ev the property change event
 339:      */
 340:     public void propertyChange(PropertyChangeEvent ev)
 341:     {
 342:       String propName = ev.getPropertyName();
 343:       if (propName.equals("model"))
 344:         {
 345:           ListSelectionModel rowSel = table.getSelectionModel();
 346:           rowSel.clearSelection();
 347:           ListSelectionModel colSel = table.getColumnModel().getSelectionModel();
 348:           colSel.clearSelection();
 349:           TableModel model = table.getModel();
 350: 
 351:           // Adjust lead and anchor selection indices of the row and column
 352:           // selection models.
 353:           if (model.getRowCount() > 0)
 354:             {
 355:               rowSel.setAnchorSelectionIndex(0);
 356:               rowSel.setLeadSelectionIndex(0);
 357:             }
 358:           else
 359:             {
 360:               rowSel.setAnchorSelectionIndex(-1);
 361:               rowSel.setLeadSelectionIndex(-1);
 362:             }
 363:           if (model.getColumnCount() > 0)
 364:             {
 365:               colSel.setAnchorSelectionIndex(0);
 366:               colSel.setLeadSelectionIndex(0);
 367:             }
 368:           else
 369:             {
 370:               colSel.setAnchorSelectionIndex(-1);
 371:               colSel.setLeadSelectionIndex(-1);
 372:             }
 373:         }
 374:     }
 375:   }
 376: 
 377:   protected FocusListener createFocusListener() 
 378:   {
 379:     return new FocusHandler();
 380:   }
 381: 
 382:   protected MouseInputListener createMouseInputListener() 
 383:   {
 384:     return new MouseInputHandler();
 385:   }
 386: 
 387: 
 388:   /**
 389:    * Creates and returns a key listener for the JTable.
 390:    *
 391:    * @return a key listener for the JTable
 392:    */
 393:   protected KeyListener createKeyListener()
 394:   {
 395:     return new KeyHandler();
 396:   }
 397: 
 398:   /**
 399:    * Return the maximum size of the table. The maximum height is the row 
 400:     * height times the number of rows. The maximum width is the sum of 
 401:     * the maximum widths of each column.
 402:     * 
 403:     *  @param comp the component whose maximum size is being queried,
 404:     *  this is ignored.
 405:     *  @return a Dimension object representing the maximum size of the table,
 406:     *  or null if the table has no elements.
 407:    */
 408:   public Dimension getMaximumSize(JComponent comp) 
 409:   {
 410:     int maxTotalColumnWidth = 0;
 411:     for (int i = 0; i < table.getColumnCount(); i++)
 412:       maxTotalColumnWidth += table.getColumnModel().getColumn(i).getMaxWidth();
 413: 
 414:     return new Dimension(maxTotalColumnWidth, getHeight());
 415:   }
 416: 
 417:   /**
 418:    * Return the minimum size of the table. The minimum height is the row 
 419:     * height times the number of rows. The minimum width is the sum of 
 420:     * the minimum widths of each column.
 421:     * 
 422:     *  @param comp the component whose minimum size is being queried,
 423:     *  this is ignored.
 424:     *  @return a Dimension object representing the minimum size of the table,
 425:     *  or null if the table has no elements.
 426:    */
 427:   public Dimension getMinimumSize(JComponent comp) 
 428:   {
 429:     int minTotalColumnWidth = 0;
 430:     for (int i = 0; i < table.getColumnCount(); i++)
 431:       minTotalColumnWidth += table.getColumnModel().getColumn(i).getMinWidth();
 432: 
 433:     return new Dimension(minTotalColumnWidth, getHeight());
 434:   }
 435: 
 436:   /**
 437:    * Returns the preferred size for the table of that UI.
 438:    *
 439:    * @param comp ignored, the <code>table</code> field is used instead
 440:    *
 441:    * @return the preferred size for the table of that UI
 442:    */
 443:   public Dimension getPreferredSize(JComponent comp) 
 444:   {
 445:     int prefTotalColumnWidth = 0;
 446:     TableColumnModel tcm = table.getColumnModel();
 447: 
 448:     for (int i = 0; i < tcm.getColumnCount(); i++)
 449:       {
 450:         TableColumn col = tcm.getColumn(i);
 451:         prefTotalColumnWidth += col.getPreferredWidth();
 452:       }
 453: 
 454:     return new Dimension(prefTotalColumnWidth, getHeight());
 455:   }
 456: 
 457:   /**
 458:    * Returns the table height. This helper method is used by
 459:    * {@link #getMinimumSize(JComponent)}, {@link #getPreferredSize(JComponent)}
 460:    * and {@link #getMaximumSize(JComponent)} to determine the table height.
 461:    * 
 462:    * @return the table height
 463:    */
 464:   private int getHeight()
 465:   {
 466:     int height = 0;
 467:     int rowCount = table.getRowCount(); 
 468:     if (rowCount > 0 && table.getColumnCount() > 0)
 469:       {
 470:         Rectangle r = table.getCellRect(rowCount - 1, 0, true);
 471:         height = r.y + r.height;
 472:       }
 473:     return height;
 474:   }
 475: 
 476:   protected void installDefaults() 
 477:   {
 478:     LookAndFeel.installColorsAndFont(table, "Table.background",
 479:                                      "Table.foreground", "Table.font");
 480:     table.setGridColor(UIManager.getColor("Table.gridColor"));
 481:     table.setSelectionForeground(UIManager.getColor("Table.selectionForeground"));
 482:     table.setSelectionBackground(UIManager.getColor("Table.selectionBackground"));
 483:     table.setOpaque(true);
 484:   }
 485: 
 486:   /**
 487:    * Installs keyboard actions on the table.
 488:    */
 489:   protected void installKeyboardActions() 
 490:   {
 491:     // Install the input map.
 492:     InputMap inputMap =
 493:       (InputMap) SharedUIDefaults.get("Table.ancestorInputMap");
 494:     SwingUtilities.replaceUIInputMap(table,
 495:                                  JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
 496:                                  inputMap);
 497: 
 498:     // FIXME: The JDK uses a LazyActionMap for parentActionMap
 499:     SwingUtilities.replaceUIActionMap(table, getActionMap());
 500: 
 501:   }
 502: 
 503:   /**
 504:    * Fetches the action map from  the UI defaults, or create a new one
 505:    * if the action map hasn't been initialized.
 506:    *
 507:    * @return the action map
 508:    */
 509:   private ActionMap getActionMap()
 510:   {
 511:     ActionMap am = (ActionMap) UIManager.get("Table.actionMap");
 512:     if (am == null)
 513:       {
 514:         am = createDefaultActions();
 515:         UIManager.getLookAndFeelDefaults().put("Table.actionMap", am);
 516:       }
 517:     return am;
 518:   }
 519: 
 520:   private ActionMap createDefaultActions()
 521:   {
 522:     ActionMapUIResource am = new ActionMapUIResource();
 523:     Action action = new TableAction();
 524: 
 525:     am.put("cut", TransferHandler.getCutAction());
 526:     am.put("copy", TransferHandler.getCopyAction());
 527:     am.put("paste", TransferHandler.getPasteAction());
 528: 
 529:     am.put("cancel", action);
 530:     am.put("selectAll", action);
 531:     am.put("clearSelection", action);
 532:     am.put("startEditing", action);
 533: 
 534:     am.put("selectNextRow", action);
 535:     am.put("selectNextRowCell", action);
 536:     am.put("selectNextRowExtendSelection", action);
 537:     am.put("selectNextRowChangeLead", action);
 538: 
 539:     am.put("selectPreviousRow", action);
 540:     am.put("selectPreviousRowCell", action);
 541:     am.put("selectPreviousRowExtendSelection", action);
 542:     am.put("selectPreviousRowChangeLead", action);
 543: 
 544:     am.put("selectNextColumn", action);
 545:     am.put("selectNextColumnCell", action);
 546:     am.put("selectNextColumnExtendSelection", action);
 547:     am.put("selectNextColumnChangeLead", action);
 548: 
 549:     am.put("selectPreviousColumn", action);
 550:     am.put("selectPreviousColumnCell", action);
 551:     am.put("selectPreviousColumnExtendSelection", action);
 552:     am.put("selectPreviousColumnChangeLead", action);
 553: 
 554:     am.put("scrollLeftChangeSelection", action);
 555:     am.put("scrollLeftExtendSelection", action);
 556:     am.put("scrollRightChangeSelection", action);
 557:     am.put("scrollRightExtendSelection", action);
 558: 
 559:     am.put("scrollUpChangeSelection", action);
 560:     am.put("scrollUpExtendSelection", action);
 561:     am.put("scrollDownChangeSelection", action);
 562:     am.put("scrolldownExtendSelection", action);
 563: 
 564:     am.put("selectFirstColumn", action);
 565:     am.put("selectFirstColumnExtendSelection", action);
 566:     am.put("selectLastColumn", action);
 567:     am.put("selectLastColumnExtendSelection", action);
 568: 
 569:     am.put("selectFirstRow", action);
 570:     am.put("selectFirstRowExtendSelection", action);
 571:     am.put("selectLastRow", action);
 572:     am.put("selectLastRowExtendSelection", action);
 573: 
 574:     am.put("addToSelection", action);
 575:     am.put("toggleAndAnchor", action);
 576:     am.put("extendTo", action);
 577:     am.put("moveSelectionTo", action);
 578: 
 579:     return am;
 580:   }
 581: 
 582:   /**
 583:    * This class implements the actions that we want to happen
 584:    * when specific keys are pressed for the JTable.  The actionPerformed
 585:    * method is called when a key that has been registered for the JTable
 586:    * is received.
 587:    */
 588:   private static class TableAction
 589:     extends AbstractAction
 590:   {
 591:     /**
 592:      * What to do when this action is called.
 593:      *
 594:      * @param e the ActionEvent that caused this action.
 595:      */
 596:     public void actionPerformed(ActionEvent e)
 597:     {
 598:       JTable table = (JTable) e.getSource();
 599: 
 600:       DefaultListSelectionModel rowModel 
 601:           = (DefaultListSelectionModel) table.getSelectionModel();
 602:       DefaultListSelectionModel colModel 
 603:           = (DefaultListSelectionModel) table.getColumnModel().getSelectionModel();
 604: 
 605:       int rowLead = rowModel.getLeadSelectionIndex();
 606:       int rowMax = table.getModel().getRowCount() - 1;
 607:       
 608:       int colLead = colModel.getLeadSelectionIndex();
 609:       int colMax = table.getModel().getColumnCount() - 1;
 610: 
 611:       // The command with which the action has been called is stored
 612:       // in this undocumented action value. This allows us to have only
 613:       // one Action instance to serve all keyboard input for JTable.
 614:       String command = (String) getValue("__command__");
 615:       if (command.equals("selectPreviousRowExtendSelection"))
 616:         {
 617:           rowModel.setLeadSelectionIndex(Math.max(rowLead - 1, 0));
 618:         }
 619:       else if (command.equals("selectLastColumn"))
 620:         {
 621:           colModel.setSelectionInterval(colMax, colMax);
 622:         }
 623:       else if (command.equals("startEditing"))
 624:         {
 625:           if (table.isCellEditable(rowLead, colLead))
 626:             table.editCellAt(rowLead, colLead);
 627:         }
 628:       else if (command.equals("selectFirstRowExtendSelection"))
 629:         {              
 630:           rowModel.setLeadSelectionIndex(0);
 631:         }
 632:       else if (command.equals("selectFirstColumn"))
 633:         {
 634:           colModel.setSelectionInterval(0, 0);
 635:         }
 636:       else if (command.equals("selectFirstColumnExtendSelection"))
 637:         {
 638:           colModel.setLeadSelectionIndex(0);
 639:         }      
 640:       else if (command.equals("selectLastRow"))
 641:         {
 642:           rowModel.setSelectionInterval(rowMax, rowMax);
 643:         }
 644:       else if (command.equals("selectNextRowExtendSelection"))
 645:         {
 646:           rowModel.setLeadSelectionIndex(Math.min(rowLead + 1, rowMax));
 647:         }
 648:       else if (command.equals("selectFirstRow"))
 649:         {
 650:           rowModel.setSelectionInterval(0, 0);
 651:         }
 652:       else if (command.equals("selectNextColumnExtendSelection"))
 653:         {
 654:           colModel.setLeadSelectionIndex(Math.min(colLead + 1, colMax));
 655:         }
 656:       else if (command.equals("selectLastColumnExtendSelection"))
 657:         {
 658:           colModel.setLeadSelectionIndex(colMax);
 659:         }
 660:       else if (command.equals("selectPreviousColumnExtendSelection"))
 661:         {
 662:           colModel.setLeadSelectionIndex(Math.max(colLead - 1, 0));
 663:         }
 664:       else if (command.equals("selectNextRow"))
 665:         {
 666:           rowModel.setSelectionInterval(Math.min(rowLead + 1, rowMax),
 667:                                         Math.min(rowLead + 1, rowMax));
 668:         }
 669:       else if (command.equals("scrollUpExtendSelection"))
 670:         {
 671:           int target;
 672:           if (rowLead == getFirstVisibleRowIndex(table))
 673:             target = Math.max(0, rowLead - (getLastVisibleRowIndex(table) 
 674:                 - getFirstVisibleRowIndex(table) + 1));
 675:           else
 676:             target = getFirstVisibleRowIndex(table);
 677:           
 678:           rowModel.setLeadSelectionIndex(target);
 679:           colModel.setLeadSelectionIndex(colLead);
 680:         }
 681:       else if (command.equals("selectPreviousRow"))
 682:         {
 683:           rowModel.setSelectionInterval(Math.max(rowLead - 1, 0),
 684:                                         Math.max(rowLead - 1, 0));
 685:         }
 686:       else if (command.equals("scrollRightChangeSelection"))
 687:         {
 688:           int target;
 689:           if (colLead == getLastVisibleColumnIndex(table))
 690:             target = Math.min(colMax, colLead
 691:                               + (getLastVisibleColumnIndex(table)
 692:                               - getFirstVisibleColumnIndex(table) + 1));
 693:           else
 694:             target = getLastVisibleColumnIndex(table);
 695:           
 696:           colModel.setSelectionInterval(target, target);
 697:           rowModel.setSelectionInterval(rowLead, rowLead);
 698:         }
 699:       else if (command.equals("selectPreviousColumn"))
 700:         {
 701:           colModel.setSelectionInterval(Math.max(colLead - 1, 0),
 702:                                         Math.max(colLead - 1, 0));
 703:         }
 704:       else if (command.equals("scrollLeftChangeSelection"))
 705:         {
 706:           int target;
 707:           if (colLead == getFirstVisibleColumnIndex(table))
 708:             target = Math.max(0, colLead - (getLastVisibleColumnIndex(table) 
 709:                                  - getFirstVisibleColumnIndex(table) + 1));
 710:           else
 711:             target = getFirstVisibleColumnIndex(table);
 712:           
 713:           colModel.setSelectionInterval(target, target);
 714:           rowModel.setSelectionInterval(rowLead, rowLead);
 715:         }
 716:       else if (command.equals("clearSelection"))
 717:         {
 718:           table.clearSelection();
 719:         }
 720:       else if (command.equals("cancel"))
 721:         {
 722:           // FIXME: implement other parts of "cancel" like undo-ing last
 723:           // selection.  Right now it just calls editingCancelled if
 724:           // we're currently editing.
 725:           if (table.isEditing())
 726:             table.editingCanceled(new ChangeEvent("cancel"));
 727:         }
 728:       else if (command.equals("selectNextRowCell")
 729:                || command.equals("selectPreviousRowCell")
 730:                || command.equals("selectNextColumnCell")
 731:                || command.equals("selectPreviousColumnCell"))
 732:         {
 733:           // If nothing is selected, select the first cell in the table
 734:           if (table.getSelectedRowCount() == 0 && 
 735:               table.getSelectedColumnCount() == 0)
 736:             {
 737:               rowModel.setSelectionInterval(0, 0);
 738:               colModel.setSelectionInterval(0, 0);
 739:               return;
 740:             }
 741:           
 742:           // If the lead selection index isn't selected (ie a remove operation
 743:           // happened, then set the lead to the first selected cell in the
 744:           // table
 745:           if (!table.isCellSelected(rowLead, colLead))
 746:             {
 747:               rowModel.addSelectionInterval(rowModel.getMinSelectionIndex(), 
 748:                                             rowModel.getMinSelectionIndex());
 749:               colModel.addSelectionInterval(colModel.getMinSelectionIndex(), 
 750:                                             colModel.getMinSelectionIndex());
 751:               return;
 752:             }
 753:           
 754:           // multRowsSelected and multColsSelected tell us if multiple rows or
 755:           // columns are selected, respectively
 756:           boolean multRowsSelected, multColsSelected;
 757:           multRowsSelected = table.getSelectedRowCount() > 1 &&
 758:             table.getRowSelectionAllowed();
 759:           
 760:           multColsSelected = table.getSelectedColumnCount() > 1 &&
 761:             table.getColumnSelectionAllowed();
 762:           
 763:           // If there is just one selection, select the next cell, and wrap
 764:           // when you get to the edges of the table.
 765:           if (!multColsSelected && !multRowsSelected)
 766:             {
 767:               if (command.indexOf("Column") != -1) 
 768:                 advanceSingleSelection(colModel, colMax, rowModel, rowMax, 
 769:                     command.equals("selectPreviousColumnCell"));
 770:               else
 771:                 advanceSingleSelection(rowModel, rowMax, colModel, colMax, 
 772:                     command.equals("selectPreviousRowCell"));
 773:               return;
 774:             }
 775:           
 776:           
 777:           // rowMinSelected and rowMaxSelected are the minimum and maximum
 778:           // values respectively of selected cells in the row selection model
 779:           // Similarly for colMinSelected and colMaxSelected.
 780:           int rowMaxSelected = table.getRowSelectionAllowed() ? 
 781:             rowModel.getMaxSelectionIndex() : table.getModel().getRowCount() - 1;
 782:           int rowMinSelected = table.getRowSelectionAllowed() ? 
 783:             rowModel.getMinSelectionIndex() : 0; 
 784:           int colMaxSelected = table.getColumnSelectionAllowed() ? 
 785:             colModel.getMaxSelectionIndex() : 
 786:             table.getModel().getColumnCount() - 1;
 787:           int colMinSelected = table.getColumnSelectionAllowed() ? 
 788:             colModel.getMinSelectionIndex() : 0;
 789:           
 790:           // If there are multiple rows and columns selected, select the next
 791:           // cell and wrap at the edges of the selection.  
 792:           if (command.indexOf("Column") != -1) 
 793:             advanceMultipleSelection(table, colModel, colMinSelected,
 794:                                      colMaxSelected, rowModel, rowMinSelected,
 795:                                      rowMaxSelected,
 796:                                     command.equals("selectPreviousColumnCell"),
 797:                                     true);
 798:           
 799:           else
 800:             advanceMultipleSelection(table, rowModel, rowMinSelected,
 801:                                      rowMaxSelected, colModel, colMinSelected,
 802:                                      colMaxSelected,
 803:                                      command.equals("selectPreviousRowCell"),
 804:                                      false);
 805:         }
 806:       else if (command.equals("selectNextColumn"))
 807:         {
 808:           colModel.setSelectionInterval(Math.min(colLead + 1, colMax),
 809:                                         Math.min(colLead + 1, colMax));
 810:         }
 811:       else if (command.equals("scrollLeftExtendSelection"))
 812:         {
 813:           int target;
 814:           if (colLead == getFirstVisibleColumnIndex(table))
 815:             target = Math.max(0, colLead - (getLastVisibleColumnIndex(table) 
 816:                                  - getFirstVisibleColumnIndex(table) + 1));
 817:           else
 818:             target = getFirstVisibleColumnIndex(table);
 819:           
 820:           colModel.setLeadSelectionIndex(target);
 821:           rowModel.setLeadSelectionIndex(rowLead);
 822:         }
 823:       else if (command.equals("scrollDownChangeSelection"))
 824:         {
 825:           int target;
 826:           if (rowLead == getLastVisibleRowIndex(table))
 827:             target = Math.min(rowMax, rowLead + (getLastVisibleRowIndex(table)
 828:                                       - getFirstVisibleRowIndex(table) + 1));
 829:           else
 830:             target = getLastVisibleRowIndex(table);
 831:           
 832:           rowModel.setSelectionInterval(target, target);
 833:           colModel.setSelectionInterval(colLead, colLead);
 834:         }
 835:       else if (command.equals("scrollRightExtendSelection"))
 836:         {
 837:           int target;
 838:           if (colLead == getLastVisibleColumnIndex(table))
 839:             target = Math.min(colMax, colLead + (getLastVisibleColumnIndex(table) 
 840:                 - getFirstVisibleColumnIndex(table) + 1));
 841:           else
 842:             target = getLastVisibleColumnIndex(table);
 843:           
 844:           colModel.setLeadSelectionIndex(target);
 845:           rowModel.setLeadSelectionIndex(rowLead);
 846:         }
 847:       else if (command.equals("selectAll"))
 848:         {
 849:           table.selectAll();
 850:         }
 851:       else if (command.equals("selectLastRowExtendSelection"))
 852:         {
 853:           rowModel.setLeadSelectionIndex(rowMax);
 854:           colModel.setLeadSelectionIndex(colLead);
 855:         }
 856:       else if (command.equals("scrollDownExtendSelection"))
 857:         {
 858:           int target;
 859:           if (rowLead == getLastVisibleRowIndex(table))
 860:             target = Math.min(rowMax, rowLead + (getLastVisibleRowIndex(table) 
 861:                 - getFirstVisibleRowIndex(table) + 1));
 862:           else
 863:             target = getLastVisibleRowIndex(table);
 864:           
 865:           rowModel.setLeadSelectionIndex(target);
 866:           colModel.setLeadSelectionIndex(colLead);
 867:         }      
 868:       else if (command.equals("scrollUpChangeSelection"))
 869:         {
 870:           int target;
 871:           if (rowLead == getFirstVisibleRowIndex(table))
 872:             target = Math.max(0, rowLead - (getLastVisibleRowIndex(table) 
 873:                 - getFirstVisibleRowIndex(table) + 1));
 874:           else
 875:             target = getFirstVisibleRowIndex(table);
 876:           
 877:           rowModel.setSelectionInterval(target, target);
 878:           colModel.setSelectionInterval(colLead, colLead);
 879:         }
 880:       else if (command.equals("selectNextRowChangeLead"))
 881:           {
 882:             if (rowModel.getSelectionMode() 
 883:                 != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
 884:               {
 885:                 // just "selectNextRow"
 886:                 rowModel.setSelectionInterval(Math.min(rowLead + 1, rowMax),
 887:                                               Math.min(rowLead + 1, rowMax));
 888:                 colModel.setSelectionInterval(colLead, colLead);
 889:               }
 890:             else
 891:               rowModel.moveLeadSelectionIndex(Math.min(rowLead + 1, rowMax));
 892:           }
 893:       else if (command.equals("selectPreviousRowChangeLead"))
 894:         {
 895:           if (rowModel.getSelectionMode() 
 896:               != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
 897:             {
 898:               // just selectPreviousRow
 899:               rowModel.setSelectionInterval(Math.max(rowLead - 1, 0),
 900:                                             Math.min(rowLead - 1, 0));
 901:               colModel.setSelectionInterval(colLead, colLead);
 902:             }
 903:           else
 904:             rowModel.moveLeadSelectionIndex(Math.max(rowLead - 1, 0));
 905:         }
 906:       else if (command.equals("selectNextColumnChangeLead"))
 907:         {
 908:           if (colModel.getSelectionMode() 
 909:               != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)            
 910:             {
 911:               // just selectNextColumn
 912:               rowModel.setSelectionInterval(rowLead, rowLead);
 913:               colModel.setSelectionInterval(Math.min(colLead + 1, colMax),
 914:                                             Math.min(colLead + 1, colMax));
 915:             }
 916:           else
 917:             colModel.moveLeadSelectionIndex(Math.min(colLead + 1, colMax));
 918:         }
 919:       else if (command.equals("selectPreviousColumnChangeLead"))
 920:         {
 921:           if (colModel.getSelectionMode() 
 922:               != ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)            
 923:             {
 924:               // just selectPreviousColumn
 925:               rowModel.setSelectionInterval(rowLead, rowLead);
 926:               colModel.setSelectionInterval(Math.max(colLead - 1, 0),
 927:                                             Math.max(colLead - 1, 0));
 928:               
 929:             }
 930:           else
 931:             colModel.moveLeadSelectionIndex(Math.max(colLead - 1, 0));
 932:         }
 933:       else if (command.equals("addToSelection"))
 934:           {
 935:             if (!table.isEditing())
 936:               {
 937:                 int oldRowAnchor = rowModel.getAnchorSelectionIndex();
 938:                 int oldColAnchor = colModel.getAnchorSelectionIndex();
 939:                 rowModel.addSelectionInterval(rowLead, rowLead);
 940:                 colModel.addSelectionInterval(colLead, colLead);
 941:                 rowModel.setAnchorSelectionIndex(oldRowAnchor);
 942:                 colModel.setAnchorSelectionIndex(oldColAnchor);
 943:               }
 944:           }
 945:       else if (command.equals("extendTo"))
 946:         {
 947:           rowModel.setSelectionInterval(rowModel.getAnchorSelectionIndex(),
 948:                                         rowLead);
 949:           colModel.setSelectionInterval(colModel.getAnchorSelectionIndex(),
 950:                                         colLead);
 951:         }
 952:       else if (command.equals("toggleAndAnchor"))
 953:         {
 954:           if (rowModel.isSelectedIndex(rowLead))
 955:             rowModel.removeSelectionInterval(rowLead, rowLead);
 956:           else
 957:             rowModel.addSelectionInterval(rowLead, rowLead);
 958:           
 959:           if (colModel.isSelectedIndex(colLead))
 960:             colModel.removeSelectionInterval(colLead, colLead);
 961:           else
 962:             colModel.addSelectionInterval(colLead, colLead);
 963:           
 964:           rowModel.setAnchorSelectionIndex(rowLead);
 965:           colModel.setAnchorSelectionIndex(colLead);
 966:         }
 967:       else if (command.equals("stopEditing"))
 968:         {
 969:           table.editingStopped(new ChangeEvent(command));
 970:         }
 971:       else 
 972:         {
 973:           // If we're here that means we bound this TableAction class
 974:           // to a keyboard input but we either want to ignore that input
 975:           // or we just haven't implemented its action yet.
 976:           
 977:           // Uncomment the following line to print the names of unused bindings
 978:           // when their keys are pressed
 979:           
 980:           // System.out.println ("not implemented: "+e.getActionCommand());
 981:         }
 982: 
 983:       // Any commands whose keyStrokes should be used by the Editor should not
 984:       // cause editing to be stopped: ie, the SPACE sends "addToSelection" but 
 985:       // if the table is in editing mode, the space should not cause us to stop
 986:       // editing because it should be used by the Editor.
 987:       if (table.isEditing() && command != "startEditing"
 988:           && command != "addToSelection")
 989:         table.editingStopped(new ChangeEvent("update"));
 990:             
 991:       table.scrollRectToVisible(table.getCellRect(
 992:           rowModel.getLeadSelectionIndex(), colModel.getLeadSelectionIndex(), 
 993:           false));
 994:     }
 995:     
 996:     /**
 997:      * Returns the column index of the first visible column.
 998:      * @return the column index of the first visible column.
 999:      */
1000:     int getFirstVisibleColumnIndex(JTable table)
1001:     {
1002:       ComponentOrientation or = table.getComponentOrientation();
1003:       Rectangle r = table.getVisibleRect();
1004:       if (!or.isLeftToRight())
1005:         r.translate((int) r.getWidth() - 1, 0);
1006:       return table.columnAtPoint(r.getLocation());
1007:     }
1008:     
1009:     /**
1010:      * Returns the column index of the last visible column.
1011:      *
1012:      */
1013:     int getLastVisibleColumnIndex(JTable table)
1014:     {
1015:       ComponentOrientation or = table.getComponentOrientation();
1016:       Rectangle r = table.getVisibleRect();
1017:       if (or.isLeftToRight())
1018:         r.translate((int) r.getWidth() - 1, 0);
1019:       return table.columnAtPoint(r.getLocation());      
1020:     }
1021:     
1022:     /**
1023:      * Returns the row index of the first visible row.
1024:      *
1025:      */
1026:     int getFirstVisibleRowIndex(JTable table)
1027:     {
1028:       ComponentOrientation or = table.getComponentOrientation();
1029:       Rectangle r = table.getVisibleRect();
1030:       if (!or.isLeftToRight())
1031:         r.translate((int) r.getWidth() - 1, 0);
1032:       return table.rowAtPoint(r.getLocation());
1033:     }
1034:     
1035:     /**
1036:      * Returns the row index of the last visible row.
1037:      *
1038:      */
1039:     int getLastVisibleRowIndex(JTable table)
1040:     {
1041:       ComponentOrientation or = table.getComponentOrientation();
1042:       Rectangle r = table.getVisibleRect();
1043:       r.translate(0, (int) r.getHeight() - 1);
1044:       if (or.isLeftToRight())
1045:         r.translate((int) r.getWidth() - 1, 0);
1046:       // The next if makes sure that we don't return -1 simply because
1047:       // there is white space at the bottom of the table (ie, the display
1048:       // area is larger than the table)
1049:       if (table.rowAtPoint(r.getLocation()) == -1)
1050:         {
1051:           if (getFirstVisibleRowIndex(table) == -1)
1052:             return -1;
1053:           else
1054:             return table.getModel().getRowCount() - 1;
1055:         }
1056:       return table.rowAtPoint(r.getLocation());
1057:     }
1058: 
1059:     /**
1060:      * A helper method for the key bindings.  Used because the actions
1061:      * for TAB, SHIFT-TAB, ENTER, and SHIFT-ENTER are very similar.
1062:      *
1063:      * Selects the next (previous if SHIFT pressed) column for TAB, or row for
1064:      * ENTER from within the currently selected cells.
1065:      *
1066:      * @param firstModel the ListSelectionModel for columns (TAB) or
1067:      * rows (ENTER)
1068:      * @param firstMin the first selected index in firstModel
1069:      * @param firstMax the last selected index in firstModel
1070:      * @param secondModel the ListSelectionModel for rows (TAB) or 
1071:      * columns (ENTER)
1072:      * @param secondMin the first selected index in secondModel
1073:      * @param secondMax the last selected index in secondModel
1074:      * @param reverse true if shift was held for the event
1075:      * @param eventIsTab true if TAB was pressed, false if ENTER pressed
1076:      */
1077:     void advanceMultipleSelection(JTable table, ListSelectionModel firstModel,
1078:                                   int firstMin,
1079:                                   int firstMax, ListSelectionModel secondModel, 
1080:                                   int secondMin, int secondMax, boolean reverse,
1081:                                   boolean eventIsTab)
1082:     {
1083:       // If eventIsTab, all the "firsts" correspond to columns, otherwise, to 
1084:       // rows "seconds" correspond to the opposite
1085:       int firstLead = firstModel.getLeadSelectionIndex();
1086:       int secondLead = secondModel.getLeadSelectionIndex();
1087:       int numFirsts = eventIsTab ? 
1088:         table.getModel().getColumnCount() : table.getModel().getRowCount();
1089:       int numSeconds = eventIsTab ? 
1090:         table.getModel().getRowCount() : table.getModel().getColumnCount();
1091: 
1092:       // check if we have to wrap the "firsts" around, going to the other side
1093:       if ((firstLead == firstMax && !reverse) || 
1094:           (reverse && firstLead == firstMin))
1095:         {
1096:           firstModel.addSelectionInterval(reverse ? firstMax : firstMin, 
1097:                                           reverse ? firstMax : firstMin);
1098:           
1099:           // check if we have to wrap the "seconds"
1100:           if ((secondLead == secondMax && !reverse) || 
1101:               (reverse && secondLead == secondMin))
1102:             secondModel.addSelectionInterval(reverse ? secondMax : secondMin, 
1103:                                              reverse ? secondMax : secondMin);
1104: 
1105:           // if we're not wrapping the seconds, we have to find out where we
1106:           // are within the secondModel and advance to the next cell (or 
1107:           // go back to the previous cell if reverse == true)
1108:           else
1109:             {
1110:               int[] secondsSelected;
1111:               if (eventIsTab && table.getRowSelectionAllowed() || 
1112:                   !eventIsTab && table.getColumnSelectionAllowed())
1113:                 secondsSelected = eventIsTab ? 
1114:                   table.getSelectedRows() : table.getSelectedColumns();
1115:               else
1116:                 {
1117:                   // if row selection is not allowed, then the entire column gets
1118:                   // selected when you click on it, so consider ALL rows selected
1119:                   secondsSelected = new int[numSeconds];
1120:                   for (int i = 0; i < numSeconds; i++)
1121:                   secondsSelected[i] = i;
1122:                 }
1123: 
1124:               // and now find the "next" index within the model
1125:               int secondIndex = reverse ? secondsSelected.length - 1 : 0;
1126:               if (!reverse)
1127:                 while (secondsSelected[secondIndex] <= secondLead)
1128:                   secondIndex++;
1129:               else
1130:                 while (secondsSelected[secondIndex] >= secondLead)
1131:                   secondIndex--;
1132:               
1133:               // and select it - updating the lead selection index
1134:               secondModel.addSelectionInterval(secondsSelected[secondIndex], 
1135:                                                secondsSelected[secondIndex]);
1136:             }
1137:         }
1138:       // We didn't have to wrap the firsts, so just find the "next" first
1139:       // and select it, we don't have to change "seconds"
1140:       else
1141:         {
1142:           int[] firstsSelected;
1143:           if (eventIsTab && table.getColumnSelectionAllowed() || 
1144:               !eventIsTab && table.getRowSelectionAllowed())
1145:             firstsSelected = eventIsTab ? 
1146:               table.getSelectedColumns() : table.getSelectedRows();
1147:           else
1148:             {
1149:               // if selection not allowed, consider ALL firsts to be selected
1150:               firstsSelected = new int[numFirsts];
1151:               for (int i = 0; i < numFirsts; i++)
1152:                 firstsSelected[i] = i;
1153:             }
1154:           int firstIndex = reverse ? firstsSelected.length - 1 : 0;
1155:           if (!reverse)
1156:             while (firstsSelected[firstIndex] <= firstLead)
1157:               firstIndex++;
1158:           else 
1159:             while (firstsSelected[firstIndex] >= firstLead)
1160:               firstIndex--;
1161:           firstModel.addSelectionInterval(firstsSelected[firstIndex], 
1162:                                           firstsSelected[firstIndex]);
1163:           secondModel.addSelectionInterval(secondLead, secondLead);
1164:         }
1165:     }
1166:     
1167:     /** 
1168:      * A helper method for the key  bindings. Used because the actions
1169:      * for TAB, SHIFT-TAB, ENTER, and SHIFT-ENTER are very similar.
1170:      *
1171:      * Selects the next (previous if SHIFT pressed) column (TAB) or row (ENTER)
1172:      * in the table, changing the current selection.  All cells in the table
1173:      * are eligible, not just the ones that are currently selected.
1174:      * @param firstModel the ListSelectionModel for columns (TAB) or rows
1175:      * (ENTER)
1176:      * @param firstMax the last index in firstModel
1177:      * @param secondModel the ListSelectionModel for rows (TAB) or columns
1178:      * (ENTER)
1179:      * @param secondMax the last index in secondModel
1180:      * @param reverse true if SHIFT was pressed for the event
1181:      */
1182: 
1183:     void advanceSingleSelection(ListSelectionModel firstModel, int firstMax, 
1184:                                 ListSelectionModel secondModel, int secondMax, 
1185:                                 boolean reverse)
1186:     {
1187:       // for TABs, "first" corresponds to columns and "seconds" to rows.
1188:       // the opposite is true for ENTERs
1189:       int firstLead = firstModel.getLeadSelectionIndex();
1190:       int secondLead = secondModel.getLeadSelectionIndex();
1191:       
1192:       // if we are going backwards subtract 2 because we later add 1
1193:       // for a net change of -1
1194:       if (reverse && (firstLead == 0))
1195:         {
1196:           // check if we have to wrap around
1197:           if (secondLead == 0)
1198:             secondLead += secondMax + 1;
1199:           secondLead -= 2;
1200:         }
1201:       
1202:       // do we have to wrap the "seconds"?
1203:       if (reverse && (firstLead == 0) || !reverse && (firstLead == firstMax))
1204:         secondModel.setSelectionInterval((secondLead + 1) % (secondMax + 1), 
1205:                                          (secondLead + 1) % (secondMax + 1));
1206:       // if not, just reselect the current lead
1207:       else
1208:         secondModel.setSelectionInterval(secondLead, secondLead);
1209:       
1210:       // if we are going backwards, subtract 2  because we add 1 later
1211:       // for net change of -1
1212:       if (reverse)
1213:         {
1214:           // check for wraparound
1215:           if (firstLead == 0)
1216:             firstLead += firstMax + 1;
1217:           firstLead -= 2;
1218:         }
1219:       // select the next "first"
1220:       firstModel.setSelectionInterval((firstLead + 1) % (firstMax + 1), 
1221:                                       (firstLead + 1) % (firstMax + 1));
1222:     }
1223:   }
1224: 
1225:   protected void installListeners() 
1226:   {
1227:     if (focusListener == null)
1228:       focusListener = createFocusListener();
1229:     table.addFocusListener(focusListener);
1230:     if (keyListener == null)
1231:       keyListener = createKeyListener();
1232:     table.addKeyListener(keyListener);
1233:     if (mouseInputListener == null)
1234:       mouseInputListener = createMouseInputListener();
1235:     table.addMouseListener(mouseInputListener);    
1236:     table.addMouseMotionListener(mouseInputListener);
1237:     if (propertyChangeListener == null)
1238:       propertyChangeListener = new PropertyChangeHandler();
1239:     table.addPropertyChangeListener(propertyChangeListener);
1240:   }
1241: 
1242:   /**
1243:    * Uninstalls UI defaults that have been installed by
1244:    * {@link #installDefaults()}.
1245:    */
1246:   protected void uninstallDefaults()
1247:   {
1248:     // Nothing to do here for now.
1249:   }
1250: 
1251:   /**
1252:    * Uninstalls the keyboard actions that have been installed by
1253:    * {@link #installKeyboardActions()}.
1254:    */
1255:   protected void uninstallKeyboardActions()
1256:   {
1257:     SwingUtilities.replaceUIInputMap(table, JComponent.
1258:                                      WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
1259:     SwingUtilities.replaceUIActionMap(table, null);
1260:   }
1261: 
1262:   protected void uninstallListeners() 
1263:   {
1264:     table.removeFocusListener(focusListener);  
1265:     table.removeKeyListener(keyListener);
1266:     table.removeMouseListener(mouseInputListener);    
1267:     table.removeMouseMotionListener(mouseInputListener);
1268:     table.removePropertyChangeListener(propertyChangeListener);
1269:     propertyChangeListener = null;
1270:   }
1271: 
1272:   public void installUI(JComponent comp) 
1273:   {
1274:     table = (JTable) comp;
1275:     rendererPane = new CellRendererPane();
1276:     table.add(rendererPane);
1277: 
1278:     installDefaults();
1279:     installKeyboardActions();
1280:     installListeners();
1281:   }
1282: 
1283:   public void uninstallUI(JComponent c) 
1284:   {
1285:     uninstallListeners();
1286:     uninstallKeyboardActions();
1287:     uninstallDefaults(); 
1288: 
1289:     table.remove(rendererPane);
1290:     rendererPane = null;
1291:     table = null;
1292:   }
1293: 
1294:   /**
1295:    * Paints a single cell in the table.
1296:    *
1297:    * @param g The graphics context to paint in
1298:    * @param row The row number to paint
1299:    * @param col The column number to paint
1300:    * @param bounds The bounds of the cell to paint, assuming a coordinate
1301:    * system beginning at <code>(0,0)</code> in the upper left corner of the
1302:    * table
1303:    * @param rend A cell renderer to paint with
1304:    */
1305:   void paintCell(Graphics g, int row, int col, Rectangle bounds,
1306:                  TableCellRenderer rend)
1307:   {
1308:     Component comp = table.prepareRenderer(rend, row, col);
1309:     rendererPane.paintComponent(g, comp, table, bounds);
1310:   }
1311:   
1312:   /**
1313:    * Paint the associated table.
1314:    */
1315:   public void paint(Graphics gfx, JComponent ignored) 
1316:   {
1317:     int ncols = table.getColumnCount();
1318:     int nrows = table.getRowCount();
1319:     if (nrows == 0 || ncols == 0)
1320:       return;
1321: 
1322:     Rectangle clip = gfx.getClipBounds();
1323: 
1324:     // Determine the range of cells that are within the clip bounds.
1325:     Point p1 = new Point(clip.x, clip.y);
1326:     int c0 = table.columnAtPoint(p1);
1327:     if (c0 == -1)
1328:       c0 = 0;
1329:     int r0 = table.rowAtPoint(p1);
1330:     if (r0 == -1)
1331:       r0 = 0;
1332:     Point p2 = new Point(clip.x + clip.width, clip.y + clip.height);
1333:     int cn = table.columnAtPoint(p2);
1334:     if (cn == -1)
1335:       cn = table.getColumnCount() - 1;
1336:     int rn = table.rowAtPoint(p2);
1337:     if (rn == -1)
1338:       rn = table.getRowCount() - 1;
1339: 
1340:     int columnMargin = table.getColumnModel().getColumnMargin();
1341:     int rowMargin = table.getRowMargin();
1342: 
1343:     TableColumnModel cmodel = table.getColumnModel();
1344:     int[] widths = new int[cn + 1];
1345:     for (int i = c0; i <= cn; i++)
1346:       {
1347:         widths[i] = cmodel.getColumn(i).getWidth() - columnMargin;
1348:       }
1349:     
1350:     Rectangle bounds = table.getCellRect(r0, c0, false);
1351:     // The left boundary of the area being repainted.
1352:     int left = bounds.x;
1353:     
1354:     // The top boundary of the area being repainted.
1355:     int top = bounds.y;
1356:     
1357:     // The bottom boundary of the area being repainted.
1358:     int bottom;
1359:     
1360:     // paint the cell contents
1361:     Color grid = table.getGridColor();    
1362:     for (int r = r0; r <= rn; ++r)
1363:       {
1364:         for (int c = c0; c <= cn; ++c)
1365:           {
1366:             bounds.width = widths[c];
1367:             paintCell(gfx, r, c, bounds, table.getCellRenderer(r, c));
1368:             bounds.x += widths[c] + columnMargin;
1369:           }
1370:         bounds.x = left;
1371:         bounds.y += table.getRowHeight(r);
1372:         // Update row height for tables with custom heights.
1373:         bounds.height = table.getRowHeight(r + 1) - rowMargin;
1374:       }
1375:     
1376:     bottom = bounds.y - rowMargin;
1377: 
1378:     // paint vertical grid lines
1379:     if (grid != null && table.getShowVerticalLines())
1380:       {    
1381:         Color save = gfx.getColor();
1382:         gfx.setColor(grid);
1383:         int x = left - columnMargin;
1384:         for (int c = c0; c <= cn; ++c)
1385:           {
1386:             // The vertical grid is draw right from the cells, so we 
1387:             // add before drawing.
1388:             x += widths[c] + columnMargin;
1389:             gfx.drawLine(x, top, x, bottom);
1390:           }
1391:         gfx.setColor(save);
1392:       }
1393: 
1394:     // paint horizontal grid lines    
1395:     if (grid != null && table.getShowHorizontalLines())
1396:       {    
1397:         Color save = gfx.getColor();
1398:         gfx.setColor(grid);
1399:         int y = top - rowMargin;
1400:         for (int r = r0; r <= rn; ++r)
1401:           {
1402:             // The horizontal grid is draw below the cells, so we 
1403:             // add before drawing.
1404:             y += table.getRowHeight(r);
1405:             gfx.drawLine(left, y, p2.x, y);
1406:           }
1407:         gfx.setColor(save);
1408:       }
1409:   }
1410: }