Source for javax.swing.table.JTableHeader

   1: /* JTableHeader.java --
   2:    Copyright (C) 2003, 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.table;
  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.PropertyChangeListener;
  51: import java.util.Locale;
  52: 
  53: import javax.accessibility.Accessible;
  54: import javax.accessibility.AccessibleAction;
  55: import javax.accessibility.AccessibleComponent;
  56: import javax.accessibility.AccessibleContext;
  57: import javax.accessibility.AccessibleRole;
  58: import javax.accessibility.AccessibleSelection;
  59: import javax.accessibility.AccessibleStateSet;
  60: import javax.accessibility.AccessibleText;
  61: import javax.accessibility.AccessibleValue;
  62: import javax.swing.JComponent;
  63: import javax.swing.JTable;
  64: import javax.swing.UIManager;
  65: import javax.swing.event.ChangeEvent;
  66: import javax.swing.event.ListSelectionEvent;
  67: import javax.swing.event.TableColumnModelEvent;
  68: import javax.swing.event.TableColumnModelListener;
  69: import javax.swing.plaf.TableHeaderUI;
  70: 
  71: /**
  72:  * Represents the table header. The header displays the column header values,
  73:  * is always visible event if the rest of the table scrolls up and down and
  74:  * supports column reordering and resizing with mouse.
  75:  */
  76: public class JTableHeader extends JComponent
  77:   implements TableColumnModelListener, Accessible
  78: {
  79:   protected class AccessibleJTableHeader extends AccessibleJComponent
  80:   {
  81:     protected class AccessibleJTableHeaderEntry extends AccessibleContext
  82:       implements Accessible, AccessibleComponent
  83:     {
  84:       
  85:       private int columnIndex;
  86:       
  87:       private JTableHeader parent;
  88:       
  89:       private JTable table;
  90:       
  91:       public AccessibleJTableHeaderEntry(int c, JTableHeader p, JTable t)
  92:       {
  93:         columnIndex = c;
  94:         parent = p;
  95:         table = t;
  96:       }
  97:       
  98:       /**
  99:        * Returns the column header renderer.
 100:        * 
 101:        * @return The column header renderer.
 102:        */
 103:       Component getColumnHeaderRenderer()
 104:       {
 105:         TableColumn tc = parent.getColumnModel().getColumn(columnIndex);
 106:         TableCellRenderer r = tc.getHeaderRenderer();
 107:         if (r == null)
 108:           r = parent.getDefaultRenderer();
 109:         return r.getTableCellRendererComponent(table, tc.headerValue, 
 110:             false, false, -1, columnIndex);
 111:       }
 112:       
 113:       /**
 114:        * Returns the accessible context for the column header renderer, or 
 115:        * <code>null</code>.
 116:        * 
 117:        * @return The accessible context.
 118:        */
 119:       AccessibleContext getAccessibleColumnHeaderRenderer()
 120:       {
 121:         Component c = getColumnHeaderRenderer();
 122:         if (c instanceof Accessible)
 123:           return c.getAccessibleContext();
 124:         return null;
 125:       }
 126:       
 127:       /**
 128:        * @see #removeFocusListener(FocusListener)
 129:        */
 130:       public void addFocusListener(FocusListener l)
 131:       {
 132:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 133:         AccessibleComponent c = ac.getAccessibleComponent();
 134:         if (c != null)
 135:           c.addFocusListener(l);
 136:       }
 137:       
 138:       /**
 139:        * @see #removePropertyChangeListener(PropertyChangeListener)
 140:        */
 141:       public void addPropertyChangeListener(PropertyChangeListener l)
 142:       {
 143:         // add the listener to the accessible context for the header
 144:         // renderer...
 145:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 146:         if (ac != null)
 147:           ac.addPropertyChangeListener(l);
 148:       }
 149:       
 150:       public boolean contains(Point p)
 151:       {
 152:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 153:         AccessibleComponent c = ac.getAccessibleComponent();
 154:         if (c != null)
 155:           return c.contains(p);
 156:         else 
 157:           return false;
 158:       }
 159:       
 160:       public AccessibleAction getAccessibleAction()
 161:       {
 162:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 163:         if (ac instanceof AccessibleAction)
 164:           return (AccessibleAction) ac;
 165:         else 
 166:           return null;
 167:       }
 168:       
 169:       public Accessible getAccessibleAt(Point p)
 170:       {
 171:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 172:         AccessibleComponent c = ac.getAccessibleComponent();
 173:         if (c != null)
 174:           return c.getAccessibleAt(p);
 175:         else
 176:           return null;
 177:       }
 178:       
 179:       /**
 180:        * Returns <code>null</code> as the header entry has no accessible
 181:        * children.
 182:        * 
 183:        * @return <code>null</code>.
 184:        */
 185:       public Accessible getAccessibleChild(int i)
 186:       {
 187:         return null;
 188:       }
 189:       
 190:       /**
 191:        * Returns the number of accessible children, zero in this case.
 192:        * 
 193:        * @return 0
 194:        */
 195:       public int getAccessibleChildrenCount()
 196:       {
 197:         return 0;
 198:       }
 199:       
 200:       /**
 201:        * Returns the accessible component for this header entry.
 202:        * 
 203:        * @return <code>this</code>.
 204:        */
 205:       public AccessibleComponent getAccessibleComponent()
 206:       {
 207:         return this;
 208:       }
 209:       
 210:       /**
 211:        * Returns the accessible context for this header entry.
 212:        * 
 213:        * @return <code>this</code>.
 214:        */
 215:       public AccessibleContext getAccessibleContext()
 216:       {
 217:         return this;
 218:       }
 219:       
 220:       /**
 221:        * Returns the accessible description.
 222:        * 
 223:        * @return The accessible description.
 224:        * 
 225:        * @see #setAccessibleDescription(String)
 226:        */
 227:       public String getAccessibleDescription()
 228:       {
 229:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 230:         if (ac != null)
 231:           return ac.getAccessibleDescription();
 232:         return accessibleDescription;
 233:       }
 234:       
 235:       /**
 236:        * Returns the index of this header entry.
 237:        * 
 238:        * @return The index of this header entry.
 239:        */
 240:       public int getAccessibleIndexInParent()
 241:       {
 242:         return columnIndex;
 243:       }
 244:       
 245:       /**
 246:        * Returns the accessible name.
 247:        * 
 248:        * @return The accessible name.
 249:        * 
 250:        * @see #setAccessibleName(String)
 251:        */
 252:       public String getAccessibleName()
 253:       {
 254:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 255:         if (ac != null)
 256:           return ac.getAccessibleName();
 257:         return accessibleName;
 258:       }
 259:       
 260:       /**
 261:        * Returns the accessible role for the header entry.
 262:        * 
 263:        * @return The accessible role.
 264:        */
 265:       public AccessibleRole getAccessibleRole()
 266:       {
 267:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 268:         if (ac != null)
 269:           return ac.getAccessibleRole();
 270:         else
 271:           return null;
 272:       }
 273:       
 274:       public AccessibleSelection getAccessibleSelection()
 275:       {
 276:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 277:         if (ac instanceof AccessibleValue)
 278:           return (AccessibleSelection) ac;
 279:         else 
 280:           return null;
 281:       }
 282:       
 283:       public AccessibleStateSet getAccessibleStateSet()
 284:       {
 285:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 286:         if (ac != null)
 287:           return ac.getAccessibleStateSet();
 288:         else 
 289:           return null;
 290:       }
 291:       
 292:       public AccessibleText getAccessibleText()
 293:       {
 294:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 295:         if (ac != null)
 296:           return ac.getAccessibleText();
 297:         else 
 298:           return null;
 299:       }
 300:       
 301:       public AccessibleValue getAccessibleValue()
 302:       {
 303:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 304:         if (ac instanceof AccessibleValue)
 305:           return (AccessibleValue) ac;
 306:         else 
 307:           return null;
 308:       }
 309:       
 310:       public Color getBackground()
 311:       {
 312:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 313:         AccessibleComponent c = ac.getAccessibleComponent();
 314:         if (c != null)
 315:           return c.getBackground();
 316:         else
 317:           return null;
 318:       }
 319:       
 320:       public Rectangle getBounds()
 321:       {
 322:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 323:         AccessibleComponent c = ac.getAccessibleComponent();
 324:         if (c != null)
 325:           return c.getBounds();
 326:         else
 327:           return null;
 328:       }
 329:       
 330:       public Cursor getCursor()
 331:       {
 332:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 333:         AccessibleComponent c = ac.getAccessibleComponent();
 334:         if (c != null)
 335:           return c.getCursor();
 336:         else
 337:           return null;
 338:       }
 339:       
 340:       public Font getFont()
 341:       {
 342:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 343:         AccessibleComponent c = ac.getAccessibleComponent();
 344:         if (c != null)
 345:           return c.getFont();
 346:         else
 347:           return null;
 348:       }
 349:       
 350:       public FontMetrics getFontMetrics(Font f)
 351:       {
 352:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 353:         AccessibleComponent c = ac.getAccessibleComponent();
 354:         if (c != null)
 355:           return c.getFontMetrics(f);
 356:         else
 357:           return null;
 358:       }
 359:       
 360:       public Color getForeground()
 361:       {
 362:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 363:         AccessibleComponent c = ac.getAccessibleComponent();
 364:         if (c != null)
 365:           return c.getForeground();
 366:         else
 367:           return null;
 368:       }
 369:       
 370:       public Locale getLocale()
 371:       {
 372:         Component c = getColumnHeaderRenderer();
 373:         if (c != null)
 374:           return c.getLocale();
 375:         return null;
 376:       }
 377:       
 378:       public Point getLocation()
 379:       {
 380:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 381:         AccessibleComponent c = ac.getAccessibleComponent();
 382:         if (c != null)
 383:           return c.getLocation();
 384:         else
 385:           return null;
 386:       }
 387:       
 388:       public Point getLocationOnScreen()
 389:       {
 390:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 391:         AccessibleComponent c = ac.getAccessibleComponent();
 392:         if (c != null)
 393:           return c.getLocationOnScreen();
 394:         else
 395:           return null;
 396:       }
 397:       
 398:       public Dimension getSize()
 399:       {
 400:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 401:         AccessibleComponent c = ac.getAccessibleComponent();
 402:         if (c != null)
 403:           return c.getSize();
 404:         else
 405:           return null;
 406:       }
 407:       
 408:       public boolean isEnabled()
 409:       {
 410:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 411:         AccessibleComponent c = ac.getAccessibleComponent();
 412:         if (c != null)
 413:           return c.isEnabled();
 414:         else
 415:           return false;
 416:       }
 417:       
 418:       public boolean isFocusTraversable()
 419:       {
 420:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 421:         AccessibleComponent c = ac.getAccessibleComponent();
 422:         if (c != null)
 423:           return c.isFocusTraversable();
 424:         else
 425:           return false;
 426:       }
 427:       
 428:       public boolean isShowing()
 429:       {
 430:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 431:         AccessibleComponent c = ac.getAccessibleComponent();
 432:         if (c != null)
 433:           return c.isShowing();
 434:         else
 435:           return false;
 436:       }
 437:       
 438:       public boolean isVisible()
 439:       {
 440:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 441:         AccessibleComponent c = ac.getAccessibleComponent();
 442:         if (c != null)
 443:           return c.isVisible();
 444:         else
 445:           return false;
 446:       }
 447:       
 448:       /**
 449:        * @see #addFocusListener(FocusListener)
 450:        */
 451:       public void removeFocusListener(FocusListener l)
 452:       {
 453:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 454:         AccessibleComponent c = ac.getAccessibleComponent();
 455:         if (c != null)
 456:           c.removeFocusListener(l);
 457:       }
 458:       
 459:       /**
 460:        * @see #addPropertyChangeListener(PropertyChangeListener)
 461:        */
 462:       public void removePropertyChangeListener(PropertyChangeListener l)
 463:       {
 464:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 465:         if (ac != null)
 466:           ac.removePropertyChangeListener(l);
 467:       }
 468:       
 469:       /**
 470:        * @see #addFocusListener(FocusListener)
 471:        */
 472:       public void requestFocus()
 473:       {
 474:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 475:         AccessibleComponent c = ac.getAccessibleComponent();
 476:         if (c != null)
 477:           c.requestFocus();
 478:       }
 479:       
 480:       /**
 481:        * @see #getAccessibleDescription()
 482:        */
 483:       public void setAccessibleDescription(String s)
 484:       {
 485:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 486:         if (ac != null)
 487:           ac.setAccessibleDescription(s);
 488:         else
 489:           accessibleDescription = s;
 490:       }
 491:       
 492:       /**
 493:        * @see #getAccessibleName()
 494:        */
 495:       public void setAccessibleName(String s)
 496:       {
 497:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 498:         if (ac != null)
 499:           ac.setAccessibleName(s);
 500:       }
 501:       
 502:       public void setBackground(Color c)
 503:       {
 504:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 505:         AccessibleComponent comp = ac.getAccessibleComponent();
 506:         if (comp != null)
 507:           comp.setBackground(c);
 508:       }
 509:       
 510:       public void setBounds(Rectangle r)
 511:       {
 512:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 513:         AccessibleComponent comp = ac.getAccessibleComponent();
 514:         if (comp != null)
 515:           comp.setBounds(r);
 516:       }
 517:       
 518:       public void setCursor(Cursor c)
 519:       {
 520:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 521:         AccessibleComponent comp = ac.getAccessibleComponent();
 522:         if (comp != null)
 523:           comp.setCursor(c);
 524:       }
 525:       
 526:       public void setEnabled(boolean b)
 527:       {
 528:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 529:         AccessibleComponent comp = ac.getAccessibleComponent();
 530:         if (comp != null)
 531:           comp.setEnabled(b);
 532:       }
 533:       
 534:       public void setFont(Font f)
 535:       {
 536:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 537:         AccessibleComponent comp = ac.getAccessibleComponent();
 538:         if (comp != null)
 539:           comp.setFont(f);
 540:       }
 541:       
 542:       public void setForeground(Color c)
 543:       {
 544:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 545:         AccessibleComponent comp = ac.getAccessibleComponent();
 546:         if (comp != null)
 547:           comp.setForeground(c);
 548:       }
 549:       
 550:       public void setLocation(Point p)
 551:       {
 552:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 553:         AccessibleComponent comp = ac.getAccessibleComponent();
 554:         if (comp != null)
 555:           comp.setLocation(p);
 556:       }
 557:       
 558:       public void setSize(Dimension d)
 559:       {
 560:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 561:         AccessibleComponent comp = ac.getAccessibleComponent();
 562:         if (comp != null)
 563:           comp.setSize(d);
 564:       }
 565:       
 566:       public void setVisible(boolean b)
 567:       {
 568:         AccessibleContext ac = getAccessibleColumnHeaderRenderer();
 569:         AccessibleComponent comp = ac.getAccessibleComponent();
 570:         if (comp != null)
 571:           comp.setVisible(b);
 572:       }
 573:     }
 574:     
 575:     public AccessibleRole getAccessibleRole()
 576:     {
 577:       return AccessibleRole.PANEL;
 578:     }
 579:     
 580:     public int getAccessibleChildrenCount()
 581:     {
 582:       return table.getColumnCount();
 583:     }
 584:     
 585:     public Accessible getAccessibleChild(int i)
 586:     {
 587:       return new AccessibleJTableHeaderEntry(i, JTableHeader.this, table);
 588:     }
 589:     
 590:     public Accessible getAccessibleAt(Point p)
 591:     {
 592:       return getAccessibleChild(columnAtPoint(p));
 593:     }
 594:   }
 595:   
 596:   /**
 597:    * Use serialVersionUid for interoperability.
 598:    */
 599:   private static final long serialVersionUID = 5144633983372967710L;
 600: 
 601:   /**
 602:    * The columnModel property.
 603:    */
 604:   protected TableColumnModel columnModel;
 605: 
 606:   /**
 607:    * The draggedColumn property.
 608:    */
 609:   protected TableColumn draggedColumn;
 610: 
 611:   /**
 612:    * The draggedDistance property.
 613:    */
 614:   protected int draggedDistance;
 615: 
 616:   /**
 617:    * The opaque property.
 618:    */
 619:   boolean opaque;
 620: 
 621:   /**
 622:    * The reorderingAllowed property.
 623:    */
 624:   protected boolean reorderingAllowed;
 625: 
 626:   /**
 627:    * The resizingAllowed property.
 628:    */
 629:   protected boolean resizingAllowed = true;
 630: 
 631:   /**
 632:    * The resizingColumn property.
 633:    */
 634:   protected TableColumn resizingColumn;
 635: 
 636:   /**
 637:    * The table property.
 638:    */
 639:   protected JTable table;
 640: 
 641:   /**
 642:    * The updateTableInRealTime property.
 643:    */
 644:   protected boolean updateTableInRealTime;
 645: 
 646:   TableCellRenderer cellRenderer; 
 647: 
 648:   /**
 649:    * Creates a new default instance.
 650:    */
 651:   public JTableHeader()
 652:   {
 653:     this(null);
 654:   }
 655: 
 656:   /**
 657:    * Creates a new header.  If <code>cm</code> is <code>null</code>, a new
 658:    * table column model is created by calling 
 659:    * {@link #createDefaultColumnModel()}.
 660:    * 
 661:    * @param cm  the table column model (<code>null</code> permitted).
 662:    */
 663:   public JTableHeader(TableColumnModel cm)
 664:   {
 665:     columnModel = cm == null ? createDefaultColumnModel() : cm; 
 666:     initializeLocalVars();
 667:     updateUI();
 668:   }
 669: 
 670:   /**
 671:    * Creates a default table column model.
 672:    * 
 673:    * @return A default table column model.
 674:    */
 675:   protected TableColumnModel createDefaultColumnModel()
 676:   {
 677:     return new DefaultTableColumnModel();
 678:   }
 679: 
 680:   /**
 681:    * Get the value of the {@link #accessibleContext} property.
 682:    *
 683:    * @return The current value of the property
 684:    */
 685:   public AccessibleContext getAccessibleContext()
 686:   {
 687:     return accessibleContext;
 688:   }
 689: 
 690:   /**
 691:    * Get the value of the {@link #columnModel} property.
 692:    *
 693:    * @return The current value of the property
 694:    */
 695:   public TableColumnModel getColumnModel()
 696:   {
 697:     return columnModel;
 698:   }
 699: 
 700:   /**
 701:    * Get the column that is currently being dragged. This is used when
 702:    * handling the column reordering with mouse.
 703:    *
 704:    * @return the column being dragged, null if none.
 705:    */
 706:   public TableColumn getDraggedColumn()
 707:   {
 708:     return draggedColumn;
 709:   }
 710: 
 711:   /**
 712:    * Get the value of the {@link #draggedDistance} property.
 713:    *
 714:    * @return The current value of the property
 715:    */
 716:   public int getDraggedDistance()
 717:   {
 718:     return draggedDistance;
 719:   }
 720: 
 721:   /**
 722:    * Check if it is possible to reorder the table columns by dragging column
 723:    * header with mouse. The table reordering is enabled by default, but can be
 724:    * disabled with {@link #setReorderingAllowed(boolean)}.
 725:    *
 726:    * @return true if reordering is allowed, false otherwise.
 727:    */ 
 728:   public boolean getReorderingAllowed()
 729:   {
 730:     return reorderingAllowed;
 731:   }
 732: 
 733:   /**
 734:    * Check if it is possible to resize the table columns by dragging the column
 735:    * boundary in the table header with mouse. The resizing is enabled
 736:    * by default, but can be disabled with {@link #setResizingAllowed(boolean)}.
 737:    *
 738:    * @return true if resizing is allowed, false otherwise.
 739:    */ 
 740:   public boolean getResizingAllowed()
 741:   {
 742:     return resizingAllowed;
 743:   }
 744: 
 745:   /**
 746:    * Get the column that is currently being resized. This is used when
 747:    * handling the column resizing with mouse.
 748:    *
 749:    * @return the column being currently resized, null if none.
 750:    */
 751:   public TableColumn getResizingColumn()
 752:   {
 753:     return resizingColumn;
 754:   }
 755: 
 756:   /**
 757:    * Get the table, having this header.
 758:    *
 759:    * @return the table, having this header.
 760:    */
 761:   public JTable getTable()
 762:   {
 763:     return table;
 764:   }
 765: 
 766:   /**
 767:    * Get the value of the {@link #updateTableInRealTime} property.
 768:    *
 769:    * @return The current value of the property
 770:    */
 771:   public boolean getUpdateTableInRealTime()
 772:   {
 773:     return updateTableInRealTime;
 774:   }
 775: 
 776:   /**
 777:    * Get the value of the {@link #opaque} property.
 778:    *
 779:    * @return The current value of the property
 780:    */
 781:   public boolean isOpaque()
 782:   {
 783:     return opaque;
 784:   }
 785: 
 786:   /**
 787:    * Set the value of the {@link #columnModel} property.
 788:    *
 789:    * @param c The new value of the property
 790:    */ 
 791:   public void setColumnModel(TableColumnModel c)
 792:   {
 793:     columnModel.removeColumnModelListener(this);
 794:     columnModel = c;
 795:     columnModel.addColumnModelListener(this);
 796:   }
 797: 
 798:   /**
 799:    * Set the column that is currently being dragged. This is used when
 800:    * dragging the column with mouse. Setting to null will stop the 
 801:    * dragging session immediately.
 802:    *
 803:    * @param draggingIt the column being currently dragged, null if none.
 804:    */ 
 805:   public void setDraggedColumn(TableColumn draggingIt)
 806:   {
 807:     draggedColumn = draggingIt;
 808:   }
 809: 
 810:   /**
 811:    * Set the value of the {@link #draggedDistance} property.
 812:    *
 813:    * @param d The new value of the property
 814:    */ 
 815:   public void setDraggedDistance(int d)
 816:   {
 817:     draggedDistance = d;
 818:   }
 819: 
 820:   /**
 821:    * Set the value of the {@link #opaque} property.
 822:    *
 823:    * @param o The new value of the property
 824:    */ 
 825:   public void setOpaque(boolean o)
 826:   {
 827:     opaque = o;
 828:   }
 829: 
 830:   /**
 831:    * Set the table ability to reorder columns by dragging column header
 832:    * with mouse. The table reordering is enabled by default, but can be
 833:    * disabled with this method.
 834:    *
 835:    * @param allowed true if reordering is allowed, false otherwise.
 836:    */ 
 837:   public void setReorderingAllowed(boolean allowed)
 838:   {
 839:     reorderingAllowed = allowed;
 840:   }
 841: 
 842:   /**
 843:    * Set the table ability to resize columns by dragging the column
 844:    * boundary in the table header with mouse. The resizing is enabled
 845:    * by default, but can be disabled using this method.
 846:    *
 847:    * @param allowed true if resizing is allowed, false otherwise.
 848:    */ 
 849:   public void setResizingAllowed(boolean allowed)
 850:   {
 851:     resizingAllowed = allowed;
 852:   }
 853: 
 854:   /**
 855:    * The the column that is currently being resized. This property is used
 856:    * when handling table resizing with mouse. Setting to null would stop
 857:    * the resizing session immediately.
 858:    *
 859:    * @param resizingIt the column being currently resized
 860:    */ 
 861:   public void setResizingColumn(TableColumn resizingIt)
 862:   {
 863:     resizingColumn = resizingIt;
 864:   }
 865: 
 866:   /**
 867:    * Set the value of the {@link #table} property.
 868:    *
 869:    * @param t The new value of the property
 870:    */ 
 871:   public void setTable(JTable t)
 872:   {
 873:     table = t;
 874:   }
 875: 
 876:   /**
 877:    * Set the value of the {@link #updateTableInRealTime} property.
 878:    *
 879:    * @param u The new value of the property
 880:    */ 
 881:   public void setUpdateTableInRealTime(boolean u)
 882:   {
 883:     updateTableInRealTime = u;
 884:   }
 885: 
 886:   /**
 887:    * Creates a default renderer.
 888:    * 
 889:    * @return A default renderer.
 890:    */
 891:   protected TableCellRenderer createDefaultRenderer()
 892:   {
 893:     return new DefaultTableCellRenderer();
 894:   }
 895:   
 896:   /**
 897:    * Returns the default table cell renderer.
 898:    * 
 899:    * @return The default table cell renderer.
 900:    */
 901:   public TableCellRenderer getDefaultRenderer()
 902:   {
 903:     return cellRenderer;
 904:   }
 905: 
 906:   /**
 907:    * Sets the default table cell renderer.
 908:    * 
 909:    * @param cellRenderer  the renderer.
 910:    */
 911:   public void setDefaultRenderer(TableCellRenderer cellRenderer)
 912:   {
 913:     this.cellRenderer = cellRenderer;
 914:   }
 915:   
 916:   /**
 917:    * Get the rectangle, occupied by the header of the given column.
 918:    * 
 919:    * @param column the column, for that the header area is requested.
 920:    * 
 921:    * @return the column header area.
 922:    */
 923:   public Rectangle getHeaderRect(int column)
 924:   {
 925:     Rectangle r = getTable().getCellRect(-1, column, false);
 926:     r.height = getHeight();
 927:     return r;
 928:   }
 929: 
 930:   protected String paramString()
 931:   {
 932:     return "JTableHeader";
 933:   }
 934: 
 935:   // UI support
 936: 
 937:   public String getUIClassID()
 938:   {
 939:     return "TableHeaderUI";
 940:   }
 941: 
 942:   public TableHeaderUI getUI()
 943:   {
 944:     return (TableHeaderUI) ui;
 945:   }
 946: 
 947:   public void setUI(TableHeaderUI u)
 948:   {
 949:     super.setUI(u);
 950:   }
 951: 
 952:   public void updateUI()
 953:   {
 954:     setUI((TableHeaderUI) UIManager.getUI(this));
 955:   }
 956: 
 957:   /**
 958:    * Returns the index of the column at the specified point.
 959:    * 
 960:    * @param point  the point.
 961:    * 
 962:    * @return The column index, or -1.
 963:    */
 964:   public int columnAtPoint(Point point)
 965:   {
 966:     if (getBounds().contains(point))
 967:       return columnModel.getColumnIndexAtX(point.x);
 968:     
 969:     return -1;
 970:   }
 971: 
 972:   /**
 973:    * Receives notification when a column is added to the column model.
 974:    *
 975:    * @param event the table column model event
 976:    */
 977:   public void columnAdded(TableColumnModelEvent event)
 978:   {
 979:     // TODO: What else to do here (if anything)?
 980:     resizeAndRepaint();
 981:   }
 982: 
 983:   /**
 984:    * Receives notification when a column margin changes in the column model.
 985:    *
 986:    * @param event the table column model event
 987:    */
 988:   public void columnMarginChanged(ChangeEvent event)
 989:   {
 990:     // TODO: What else to do here (if anything)?
 991:     resizeAndRepaint();
 992:   }
 993: 
 994:   /**
 995:    * Receives notification when a column is moved within the column model.
 996:    *
 997:    * @param event the table column model event
 998:    */
 999:   public void columnMoved(TableColumnModelEvent event)
1000:   {
1001:     // TODO: What else to do here (if anything)?
1002:     resizeAndRepaint();
1003:   }
1004: 
1005:   /**
1006:    * Receives notification when a column is removed from the column model.
1007:    *
1008:    * @param event the table column model event
1009:    */
1010:   public void columnRemoved(TableColumnModelEvent event)
1011:   {
1012:     // TODO: What else to do here (if anything)?
1013:     resizeAndRepaint();
1014:   }
1015: 
1016:   /**
1017:    * Receives notification when the column selection has changed.
1018:    *
1019:    * @param event the table column model event
1020:    */
1021:   public void columnSelectionChanged(ListSelectionEvent event)
1022:   {
1023:     // TODO: What else to do here (if anything)?
1024:     resizeAndRepaint();
1025:   }
1026: 
1027:   /**
1028:    * Validates the layout of this table header and repaints it. This is
1029:    * equivalent to <code>revalidate()</code> followed by
1030:    * <code>repaint()</code>.
1031:    */
1032:   public void resizeAndRepaint()
1033:   {
1034:     revalidate();
1035:     repaint();
1036:   }
1037: 
1038:   /**
1039:    * Initializes the fields and properties of this class with default values.
1040:    * This is called by the constructors.
1041:    */
1042:   protected void initializeLocalVars()
1043:   {
1044:     accessibleContext = new AccessibleJTableHeader();
1045:     draggedColumn = null;
1046:     draggedDistance = 0;
1047:     opaque = true;
1048:     reorderingAllowed = true;
1049:     resizingAllowed = true;
1050:     resizingColumn = null;
1051:     table = null;
1052:     updateTableInRealTime = true;
1053:     cellRenderer = createDefaultRenderer();
1054:   }
1055: }