Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing.table;

	import sun.swing.table.DefaultTableCellHeaderRenderer;

	import java.util.*;
	import java.awt.*;
	import java.awt.event.*;

	import javax.swing.*;
	import javax.swing.event.*;
	import javax.swing.plaf.*;
	import javax.accessibility.*;

	import java.beans.PropertyChangeListener;
	import java.beans.Transient;

	import java.io.ObjectOutputStream;
	import java.io.ObjectInputStream;
	import java.io.IOException;

	import sun.awt.AWTAccessor;
	import sun.awt.AWTAccessor.MouseEventAccessor;

	/**
	* This is the object which manages the header of the <code>JTable</code>.
	* <p>
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @author Alan Chung
	* @author Philip Milne
	* @see javax.swing.JTable
	*/
	public class JTableHeader extends JComponent implements TableColumnModelListener, Accessible
	{
	/**
	* @see #getUIClassID
	* @see #readObject
	*/
	private static final String uiClassID = "TableHeaderUI";

	//
	// Instance Variables
	//
	/**
	* The table for which this object is the header;
	* the default is <code>null</code>.
	*/
	protected JTable table;

	/**
	* The <code>TableColumnModel</code> of the table header.
	*/
	protected TableColumnModel columnModel;

	/**
	* If true, reordering of columns are allowed by the user;
	* the default is true.
	*/
	protected boolean reorderingAllowed;

	/**
	* If true, resizing of columns are allowed by the user;
	* the default is true.
	*/
	protected boolean resizingAllowed;

	/**
	* Obsolete as of Java 2 platform v1.3. Real time repaints, in response
	* to column dragging or resizing, are now unconditional.
	*/
	/*
	* If this flag is true, then the header will repaint the table as
	* a column is dragged or resized; the default is true.
	*/
	protected boolean updateTableInRealTime;

	/** The index of the column being resized. <code>null</code> if not resizing. */
	transient protected TableColumn resizingColumn;

	/** The index of the column being dragged. <code>null</code> if not dragging. */
	transient protected TableColumn draggedColumn;

	/** The distance from its original position the column has been dragged. */
	transient protected int draggedDistance;

	/**
	* The default renderer to be used when a <code>TableColumn</code>
	* does not define a <code>headerRenderer</code>.
	*/
	private TableCellRenderer defaultRenderer;

	//
	// Constructors
	//

	/**
	* Constructs a <code>JTableHeader</code> with a default
	* <code>TableColumnModel</code>.
	*
	* @see #createDefaultColumnModel
	*/
	public JTableHeader() {
	this(null);
	}

	/**
	* Constructs a <code>JTableHeader</code> which is initialized with
	* <code>cm</code> as the column model. If <code>cm</code> is
	* <code>null</code> this method will initialize the table header
	* with a default <code>TableColumnModel</code>.
	*
	* @param cm the column model for the table
	* @see #createDefaultColumnModel
	*/
	public JTableHeader(TableColumnModel cm) {
	super();

	//setFocusable(false); // for strict win/mac compatibility mode,
	// this method should be invoked

	if (cm == null)
	cm = createDefaultColumnModel();
	setColumnModel(cm);

	// Initialize local ivars
	initializeLocalVars();

	// Get UI going
	updateUI();
	}

	//
	// Local behavior attributes
	//

	/**
	* Sets the table associated with this header.
	* @param table the new table
	* @beaninfo
	* bound: true
	* description: The table associated with this header.
	*/
	public void setTable(JTable table) {
	JTable old = this.table;
	this.table = table;
	firePropertyChange("table", old, table);
	}

	/**
	* Returns the table associated with this header.
	* @return the <code>table</code> property
	*/
	public JTable getTable() {
	return table;
	}

	/**
	* Sets whether the user can drag column headers to reorder columns.
	*
	* @param reorderingAllowed true if the table view should allow
	* reordering; otherwise false
	* @see #getReorderingAllowed
	* @beaninfo
	* bound: true
	* description: Whether the user can drag column headers to reorder columns.
	*/
	public void setReorderingAllowed(boolean reorderingAllowed) {
	boolean old = this.reorderingAllowed;
	this.reorderingAllowed = reorderingAllowed;
	firePropertyChange("reorderingAllowed", old, reorderingAllowed);
	}

	/**
	* Returns true if the user is allowed to rearrange columns by
	* dragging their headers, false otherwise. The default is true. You can
	* rearrange columns programmatically regardless of this setting.
	*
	* @return the <code>reorderingAllowed</code> property
	* @see #setReorderingAllowed
	*/
	public boolean getReorderingAllowed() {
	return reorderingAllowed;
	}

	/**
	* Sets whether the user can resize columns by dragging between headers.
	*
	* @param resizingAllowed true if table view should allow
	* resizing
	* @see #getResizingAllowed
	* @beaninfo
	* bound: true
	* description: Whether the user can resize columns by dragging between headers.
	*/
	public void setResizingAllowed(boolean resizingAllowed) {
	boolean old = this.resizingAllowed;
	this.resizingAllowed = resizingAllowed;
	firePropertyChange("resizingAllowed", old, resizingAllowed);
	}

	/**
	* Returns true if the user is allowed to resize columns by dragging
	* between their headers, false otherwise. The default is true. You can
	* resize columns programmatically regardless of this setting.
	*
	* @return the <code>resizingAllowed</code> property
	* @see #setResizingAllowed
	*/
	public boolean getResizingAllowed() {
	return resizingAllowed;
	}

	/**
	* Returns the the dragged column, if and only if, a drag is in
	* process, otherwise returns <code>null</code>.
	*
	* @return the dragged column, if a drag is in
	* process, otherwise returns <code>null</code>
	* @see #getDraggedDistance
	*/
	public TableColumn getDraggedColumn() {
	return draggedColumn;
	}

	/**
	* Returns the column's horizontal distance from its original
	* position, if and only if, a drag is in process. Otherwise, the
	* the return value is meaningless.
	*
	* @return the column's horizontal distance from its original
	* position, if a drag is in process, otherwise the return
	* value is meaningless
	* @see #getDraggedColumn
	*/
	public int getDraggedDistance() {
	return draggedDistance;
	}

	/**
	* Returns the resizing column. If no column is being
	* resized this method returns <code>null</code>.
	*
	* @return the resizing column, if a resize is in process, otherwise
	* returns <code>null</code>
	*/
	public TableColumn getResizingColumn() {
	return resizingColumn;
	}

	/**
	* Obsolete as of Java 2 platform v1.3. Real time repaints, in response to
	* column dragging or resizing, are now unconditional.
	*/
	/*
	* Sets whether the body of the table updates in real time when
	* a column is resized or dragged.
	*
	* @param flag true if tableView should update
	* the body of the table in real time
	* @see #getUpdateTableInRealTime
	*/
	public void setUpdateTableInRealTime(boolean flag) {
	updateTableInRealTime = flag;
	}

	/**
	* Obsolete as of Java 2 platform v1.3. Real time repaints, in response to
	* column dragging or resizing, are now unconditional.
	*/
	/*
	* Returns true if the body of the table view updates in real
	* time when a column is resized or dragged. User can set this flag to
	* false to speed up the table's response to user resize or drag actions.
	* The default is true.
	*
	* @return true if the table updates in real time
	* @see #setUpdateTableInRealTime
	*/
	public boolean getUpdateTableInRealTime() {
	return updateTableInRealTime;
	}

	/**
	* Sets the default renderer to be used when no <code>headerRenderer</code>
	* is defined by a <code>TableColumn</code>.
	* @param defaultRenderer the default renderer
	* @since 1.3
	*/
	public void setDefaultRenderer(TableCellRenderer defaultRenderer) {
	this.defaultRenderer = defaultRenderer;
	}

	/**
	* Returns the default renderer used when no <code>headerRenderer</code>
	* is defined by a <code>TableColumn</code>.
	* @return the default renderer
	* @since 1.3
	*/
	@Transient
	public TableCellRenderer getDefaultRenderer() {
	return defaultRenderer;
	}

	/**
	* Returns the index of the column that <code>point</code> lies in, or -1 if it
	* lies out of bounds.
	*
	* @return the index of the column that <code>point</code> lies in, or -1 if it
	* lies out of bounds
	*/
	public int columnAtPoint(Point point) {
	int x = point.x;
	if (!getComponentOrientation().isLeftToRight()) {
	x = getWidthInRightToLeft() - x - 1;
	}
	return getColumnModel().getColumnIndexAtX(x);
	}

	/**
	* Returns the rectangle containing the header tile at <code>column</code>.
	* When the <code>column</code> parameter is out of bounds this method uses the
	* same conventions as the <code>JTable</code> method <code>getCellRect</code>.
	*
	* @return the rectangle containing the header tile at <code>column</code>
	* @see JTable#getCellRect
	*/
	public Rectangle getHeaderRect(int column) {
	Rectangle r = new Rectangle();
	TableColumnModel cm = getColumnModel();

	r.height = getHeight();

	if (column < 0) {
	// x = width = 0;
	if( !getComponentOrientation().isLeftToRight() ) {
	r.x = getWidthInRightToLeft();
	}
	}
	else if (column >= cm.getColumnCount()) {
	if( getComponentOrientation().isLeftToRight() ) {
	r.x = getWidth();
	}
	}
	else {
	for(int i = 0; i < column; i++) {
	r.x += cm.getColumn(i).getWidth();
	}
	if( !getComponentOrientation().isLeftToRight() ) {
	r.x = getWidthInRightToLeft() - r.x - cm.getColumn(column).getWidth();
	}

	r.width = cm.getColumn(column).getWidth();
	}
	return r;
	}


	/**
	* Allows the renderer's tips to be used if there is text set.
	* @param event the location of the event identifies the proper
	* renderer and, therefore, the proper tip
	* @return the tool tip for this component
	*/
	public String getToolTipText(MouseEvent event) {
	String tip = null;
	Point p = event.getPoint();
	int column;

	// Locate the renderer under the event location
	if ((column = columnAtPoint(p)) != -1) {
	TableColumn aColumn = columnModel.getColumn(column);
	TableCellRenderer renderer = aColumn.getHeaderRenderer();
	if (renderer == null) {
	renderer = defaultRenderer;
	}
	Component component = renderer.getTableCellRendererComponent(
	getTable(), aColumn.getHeaderValue(), false, false,
	-1, column);

	// Now have to see if the component is a JComponent before
	// getting the tip
	if (component instanceof JComponent) {
	// Convert the event to the renderer's coordinate system
	MouseEvent newEvent;
	Rectangle cellRect = getHeaderRect(column);

	p.translate(-cellRect.x, -cellRect.y);
	newEvent = new MouseEvent(component, event.getID(),
	event.getWhen(), event.getModifiers(),
	p.x, p.y, event.getXOnScreen(), event.getYOnScreen(),
	event.getClickCount(),
	event.isPopupTrigger(), MouseEvent.NOBUTTON);
	MouseEventAccessor meAccessor = AWTAccessor.getMouseEventAccessor();
	meAccessor.setCausedByTouchEvent(newEvent,
	meAccessor.isCausedByTouchEvent(event));

	tip = ((JComponent)component).getToolTipText(newEvent);
	}
	}

	// No tip from the renderer get our own tip
	if (tip == null)
	tip = getToolTipText();

	return tip;
	}

	//
	// Managing TableHeaderUI
	//

	/**
	* Returns the look and feel (L&F) object that renders this component.
	*
	* @return the <code>TableHeaderUI</code> object that renders this component
	*/
	public TableHeaderUI getUI() {
	return (TableHeaderUI)ui;
	}

	/**
	* Sets the look and feel (L&F) object that renders this component.
	*
	* @param ui the <code>TableHeaderUI</code> L&F object
	* @see UIDefaults#getUI
	*/
	public void setUI(TableHeaderUI ui){
	if (this.ui != ui) {
	super.setUI(ui);
	repaint();
	}
	}

	/**
	* Notification from the <code>UIManager</code> that the look and feel
	* (L&F) has changed.
	* Replaces the current UI object with the latest version from the
	* <code>UIManager</code>.
	*
	* @see JComponent#updateUI
	*/
	public void updateUI(){
	setUI((TableHeaderUI)UIManager.getUI(this));

	TableCellRenderer renderer = getDefaultRenderer();
	if (renderer instanceof Component) {
	SwingUtilities.updateComponentTreeUI((Component)renderer);
	}
	}


	/**
	* Returns the suffix used to construct the name of the look and feel
	* (L&F) class used to render this component.
	* @return the string "TableHeaderUI"
	*
	* @return "TableHeaderUI"
	* @see JComponent#getUIClassID
	* @see UIDefaults#getUI
	*/
	public String getUIClassID() {
	return uiClassID;
	}


	//
	// Managing models
	//


	/**
	* Sets the column model for this table to <code>newModel</code> and registers
	* for listener notifications from the new column model.
	*
	* @param columnModel the new data source for this table
	* @exception IllegalArgumentException
	* if <code>newModel</code> is <code>null</code>
	* @see #getColumnModel
	* @beaninfo
	* bound: true
	* description: The object governing the way columns appear in the view.
	*/
	public void setColumnModel(TableColumnModel columnModel) {
	if (columnModel == null) {
	throw new IllegalArgumentException("Cannot set a null ColumnModel");
	}
	TableColumnModel old = this.columnModel;
	if (columnModel != old) {
	if (old != null) {
	old.removeColumnModelListener(this);
	}
	this.columnModel = columnModel;
	columnModel.addColumnModelListener(this);

	firePropertyChange("columnModel", old, columnModel);
	resizeAndRepaint();
	}
	}

	/**
	* Returns the <code>TableColumnModel</code> that contains all column information
	* of this table header.
	*
	* @return the <code>columnModel</code> property
	* @see #setColumnModel
	*/
	public TableColumnModel getColumnModel() {
	return columnModel;
	}

	//
	// Implementing TableColumnModelListener interface
	//

	/**
	* Invoked when a column is added to the table column model.
	* <p>
	* Application code will not use these methods explicitly, they
	* are used internally by <code>JTable</code>.
	*
	* @param e the event received
	* @see TableColumnModelListener
	*/
	public void columnAdded(TableColumnModelEvent e) { resizeAndRepaint(); }


	/**
	* Invoked when a column is removed from the table column model.
	* <p>
	* Application code will not use these methods explicitly, they
	* are used internally by <code>JTable</code>.
	*
	* @param e the event received
	* @see TableColumnModelListener
	*/
	public void columnRemoved(TableColumnModelEvent e) { resizeAndRepaint(); }


	/**
	* Invoked when a column is repositioned.
	* <p>
	* Application code will not use these methods explicitly, they
	* are used internally by <code>JTable</code>.
	*
	* @param e the event received
	* @see TableColumnModelListener
	*/
	public void columnMoved(TableColumnModelEvent e) { repaint(); }


	/**
	* Invoked when a column is moved due to a margin change.
	* <p>
	* Application code will not use these methods explicitly, they
	* are used internally by <code>JTable</code>.
	*
	* @param e the event received
	* @see TableColumnModelListener
	*/
	public void columnMarginChanged(ChangeEvent e) { resizeAndRepaint(); }


	// --Redrawing the header is slow in cell selection mode.
	// --Since header selection is ugly and it is always clear from the
	// --view which columns are selected, don't redraw the header.
	/**
	* Invoked when the selection model of the <code>TableColumnModel</code>
	* is changed. This method currently has no effect (the header is not
	* redrawn).
	* <p>
	* Application code will not use these methods explicitly, they
	* are used internally by <code>JTable</code>.
	*
	* @param e the event received
	* @see TableColumnModelListener
	*/
	public void columnSelectionChanged(ListSelectionEvent e) { } // repaint(); }

	//
	// Package Methods
	//

	/**
	* Returns the default column model object which is
	* a <code>DefaultTableColumnModel</code>. A subclass can override this
	* method to return a different column model object
	*
	* @return the default column model object
	*/
	protected TableColumnModel createDefaultColumnModel() {
	return new DefaultTableColumnModel();
	}

	/**
	* Returns a default renderer to be used when no header renderer
	* is defined by a <code>TableColumn</code>.
	*
	* @return the default table column renderer
	* @since 1.3
	*/
	protected TableCellRenderer createDefaultRenderer() {
	return new DefaultTableCellHeaderRenderer();
	}


	/**
	* Initializes the local variables and properties with default values.
	* Used by the constructor methods.
	*/
	protected void initializeLocalVars() {
	setOpaque(true);
	table = null;
	reorderingAllowed = true;
	resizingAllowed = true;
	draggedColumn = null;
	draggedDistance = 0;
	resizingColumn = null;
	updateTableInRealTime = true;

	// I'm registered to do tool tips so we can draw tips for the
	// renderers
	ToolTipManager toolTipManager = ToolTipManager.sharedInstance();
	toolTipManager.registerComponent(this);
	setDefaultRenderer(createDefaultRenderer());
	}

	/**
	* Sizes the header and marks it as needing display. Equivalent
	* to <code>revalidate</code> followed by <code>repaint</code>.
	*/
	public void resizeAndRepaint() {
	revalidate();
	repaint();
	}

	/**
	* Sets the header's <code>draggedColumn</code> to <code>aColumn</code>.
	* <p>
	* Application code will not use this method explicitly, it is used
	* internally by the column dragging mechanism.
	*
	* @param aColumn the column being dragged, or <code>null</code> if
	* no column is being dragged
	*/
	public void setDraggedColumn(TableColumn aColumn) {
	draggedColumn = aColumn;
	}

	/**
	* Sets the header's <code>draggedDistance</code> to <code>distance</code>.
	* @param distance the distance dragged
	*/
	public void setDraggedDistance(int distance) {
	draggedDistance = distance;
	}

	/**
	* Sets the header's <code>resizingColumn</code> to <code>aColumn</code>.
	* <p>
	* Application code will not use this method explicitly, it
	* is used internally by the column sizing mechanism.
	*
	* @param aColumn the column being resized, or <code>null</code> if
	* no column is being resized
	*/
	public void setResizingColumn(TableColumn aColumn) {
	resizingColumn = aColumn;
	}

	/**
	* See <code>readObject</code> and <code>writeObject</code> in
	* <code>JComponent</code> for more
	* information about serialization in Swing.
	*/
	private void writeObject(ObjectOutputStream s) throws IOException {
	s.defaultWriteObject();
	if ((ui != null) && (getUIClassID().equals(uiClassID))) {
	ui.installUI(this);
	}
	}

	private int getWidthInRightToLeft() {
	if ((table != null) &&
	(table.getAutoResizeMode() != JTable.AUTO_RESIZE_OFF)) {
	return table.getWidth();
	}
	return super.getWidth();
	}

	/**
	* Returns a string representation of this <code>JTableHeader</code>. This method
	* is intended to be used only for debugging purposes, and the
	* content and format of the returned string may vary between
	* implementations. The returned string may be empty but may not
	* be <code>null</code>.
	* <P>
	* Overriding <code>paramString</code> to provide information about the
	* specific new aspects of the JFC components.
	*
	* @return a string representation of this <code>JTableHeader</code>
	*/
	protected String paramString() {
	String reorderingAllowedString = (reorderingAllowed ?
	"true" : "false");
	String resizingAllowedString = (resizingAllowed ?
	"true" : "false");
	String updateTableInRealTimeString = (updateTableInRealTime ?
	"true" : "false");

	return super.paramString() +
	",draggedDistance=" + draggedDistance +
	",reorderingAllowed=" + reorderingAllowedString +
	",resizingAllowed=" + resizingAllowedString +
	",updateTableInRealTime=" + updateTableInRealTimeString;
	}

	/////////////////
	// Accessibility support
	////////////////

	/**
	* Gets the AccessibleContext associated with this JTableHeader.
	* For JTableHeaders, the AccessibleContext takes the form of an
	* AccessibleJTableHeader.
	* A new AccessibleJTableHeader instance is created if necessary.
	*
	* @return an AccessibleJTableHeader that serves as the
	* AccessibleContext of this JTableHeader
	*/
	public AccessibleContext getAccessibleContext() {
	if (accessibleContext == null) {
	accessibleContext = new AccessibleJTableHeader();
	}
	return accessibleContext;
	}

	//
	// *** should also implement AccessibleSelection?
	// *** and what's up with keyboard navigation/manipulation?
	//
	/**
	* This class implements accessibility support for the
	* <code>JTableHeader</code> class. It provides an implementation of the
	* Java Accessibility API appropriate to table header user-interface
	* elements.
	* <p>
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*/
	protected class AccessibleJTableHeader extends AccessibleJComponent {

	/**
	* Get the role of this object.
	*
	* @return an instance of AccessibleRole describing the role of the
	* object
	* @see AccessibleRole
	*/
	public AccessibleRole getAccessibleRole() {
	return AccessibleRole.PANEL;
	}

	/**
	* Returns the Accessible child, if one exists, contained at the local
	* coordinate Point.
	*
	* @param p The point defining the top-left corner of the Accessible,
	* given in the coordinate space of the object's parent.
	* @return the Accessible, if it exists, at the specified location;
	* else null
	*/
	public Accessible getAccessibleAt(Point p) {
	int column;

	// Locate the renderer under the Point
	if ((column = JTableHeader.this.columnAtPoint(p)) != -1) {
	TableColumn aColumn = JTableHeader.this.columnModel.getColumn(column);
	TableCellRenderer renderer = aColumn.getHeaderRenderer();
	if (renderer == null) {
	if (defaultRenderer != null) {
	renderer = defaultRenderer;
	} else {
	return null;
	}
	}
	Component component = renderer.getTableCellRendererComponent(
	JTableHeader.this.getTable(),
	aColumn.getHeaderValue(), false, false,
	-1, column);

	return new AccessibleJTableHeaderEntry(column, JTableHeader.this, JTableHeader.this.table);
	} else {
	return null;
	}
	}

	/**
	* Returns the number of accessible children in the object. If all
	* of the children of this object implement Accessible, than this
	* method should return the number of children of this object.
	*
	* @return the number of accessible children in the object.
	*/
	public int getAccessibleChildrenCount() {
	return JTableHeader.this.columnModel.getColumnCount();
	}

	/**
	* Return the nth Accessible child of the object.
	*
	* @param i zero-based index of child
	* @return the nth Accessible child of the object
	*/
	public Accessible getAccessibleChild(int i) {
	if (i < 0 \|\| i >= getAccessibleChildrenCount()) {
	return null;
	} else {
	TableColumn aColumn = JTableHeader.this.columnModel.getColumn(i)
	;
	TableCellRenderer renderer = aColumn.getHeaderRenderer();
	if (renderer == null) {
	if (defaultRenderer != null) {
	renderer = defaultRenderer;
	} else {
	return null;
	}
	}
	Component component = renderer.getTableCellRendererComponent(
	JTableHeader.this.getTable(),
	aColumn.getHeaderValue(), false, false,
	-1, i);

	return new AccessibleJTableHeaderEntry(i, JTableHeader.this, JTableHeader.this.table);
	}
	}

	/**
	* This class provides an implementation of the Java Accessibility
	* API appropriate for JTableHeader entries.
	*/
	protected class AccessibleJTableHeaderEntry extends AccessibleContext
	implements Accessible, AccessibleComponent {

	private JTableHeader parent;
	private int column;
	private JTable table;

	/**
	* Constructs an AccessiblJTableHeaaderEntry
	* @since 1.4
	*/
	public AccessibleJTableHeaderEntry(int c, JTableHeader p, JTable t) {
	parent = p;
	column = c;
	table = t;
	this.setAccessibleParent(parent);
	}

	/**
	* Get the AccessibleContext associated with this object.
	* In the implementation of the Java Accessibility API
	* for this class, returns this object, which serves as
	* its own AccessibleContext.
	*
	* @return this object
	*/
	public AccessibleContext getAccessibleContext() {
	return this;
	}

	private AccessibleContext getCurrentAccessibleContext() {
	TableColumnModel tcm = table.getColumnModel();
	if (tcm != null) {
	// Fixes 4772355 - ArrayOutOfBoundsException in
	// JTableHeader
	if (column < 0 \|\| column >= tcm.getColumnCount()) {
	return null;
	}
	TableColumn aColumn = tcm.getColumn(column);
	TableCellRenderer renderer = aColumn.getHeaderRenderer();
	if (renderer == null) {
	if (defaultRenderer != null) {
	renderer = defaultRenderer;
	} else {
	return null;
	}
	}
	Component c = renderer.getTableCellRendererComponent(
	JTableHeader.this.getTable(),
	aColumn.getHeaderValue(), false, false,
	-1, column);
	if (c instanceof Accessible) {
	return ((Accessible) c).getAccessibleContext();
	}
	}
	return null;
	}

	private Component getCurrentComponent() {
	TableColumnModel tcm = table.getColumnModel();
	if (tcm != null) {
	// Fixes 4772355 - ArrayOutOfBoundsException in
	// JTableHeader
	if (column < 0 \|\| column >= tcm.getColumnCount()) {
	return null;
	}
	TableColumn aColumn = tcm.getColumn(column);
	TableCellRenderer renderer = aColumn.getHeaderRenderer();
	if (renderer == null) {
	if (defaultRenderer != null) {
	renderer = defaultRenderer;
	} else {
	return null;
	}
	}
	return renderer.getTableCellRendererComponent(
	JTableHeader.this.getTable(),
	aColumn.getHeaderValue(), false, false,
	-1, column);
	} else {
	return null;
	}
	}

	// AccessibleContext methods

	public String getAccessibleName() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	String name = ac.getAccessibleName();
	if ((name != null) && (name != "")) {
	// return the cell renderer's AccessibleName
	return name;
	}
	}
	if ((accessibleName != null) && (accessibleName != "")) {
	return accessibleName;
	} else {
	// fall back to the client property
	String name = (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
	if (name != null) {
	return name;
	} else {
	return table.getColumnName(column);
	}
	}
	}

	public void setAccessibleName(String s) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	ac.setAccessibleName(s);
	} else {
	super.setAccessibleName(s);
	}
	}

	//
	// *** should check toolTip text for desc. (needs MouseEvent)
	//
	public String getAccessibleDescription() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	return ac.getAccessibleDescription();
	} else {
	return super.getAccessibleDescription();
	}
	}

	public void setAccessibleDescription(String s) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	ac.setAccessibleDescription(s);
	} else {
	super.setAccessibleDescription(s);
	}
	}

	public AccessibleRole getAccessibleRole() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	return ac.getAccessibleRole();
	} else {
	return AccessibleRole.COLUMN_HEADER;
	}
	}

	public AccessibleStateSet getAccessibleStateSet() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	AccessibleStateSet states = ac.getAccessibleStateSet();
	if (isShowing()) {
	states.add(AccessibleState.SHOWING);
	}
	return states;
	} else {
	return new AccessibleStateSet(); // must be non null?
	}
	}

	public int getAccessibleIndexInParent() {
	return column;
	}

	public int getAccessibleChildrenCount() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	return ac.getAccessibleChildrenCount();
	} else {
	return 0;
	}
	}

	public Accessible getAccessibleChild(int i) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	Accessible accessibleChild = ac.getAccessibleChild(i);
	ac.setAccessibleParent(this);
	return accessibleChild;
	} else {
	return null;
	}
	}

	public Locale getLocale() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	return ac.getLocale();
	} else {
	return null;
	}
	}

	public void addPropertyChangeListener(PropertyChangeListener l) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	ac.addPropertyChangeListener(l);
	} else {
	super.addPropertyChangeListener(l);
	}
	}

	public void removePropertyChangeListener(PropertyChangeListener l) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac != null) {
	ac.removePropertyChangeListener(l);
	} else {
	super.removePropertyChangeListener(l);
	}
	}

	public AccessibleAction getAccessibleAction() {
	return getCurrentAccessibleContext().getAccessibleAction();
	}

	/**
	* Get the AccessibleComponent associated with this object. In the
	* implementation of the Java Accessibility API for this class,
	* return this object, which is responsible for implementing the
	* AccessibleComponent interface on behalf of itself.
	*
	* @return this object
	*/
	public AccessibleComponent getAccessibleComponent() {
	return this; // to override getBounds()
	}

	public AccessibleSelection getAccessibleSelection() {
	return getCurrentAccessibleContext().getAccessibleSelection();
	}

	public AccessibleText getAccessibleText() {
	return getCurrentAccessibleContext().getAccessibleText();
	}

	public AccessibleValue getAccessibleValue() {
	return getCurrentAccessibleContext().getAccessibleValue();
	}


	// AccessibleComponent methods

	public Color getBackground() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getBackground();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.getBackground();
	} else {
	return null;
	}
	}
	}

	public void setBackground(Color c) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setBackground(c);
	} else {
	Component cp = getCurrentComponent();
	if (cp != null) {
	cp.setBackground(c);
	}
	}
	}

	public Color getForeground() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getForeground();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.getForeground();
	} else {
	return null;
	}
	}
	}

	public void setForeground(Color c) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setForeground(c);
	} else {
	Component cp = getCurrentComponent();
	if (cp != null) {
	cp.setForeground(c);
	}
	}
	}

	public Cursor getCursor() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getCursor();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.getCursor();
	} else {
	Accessible ap = getAccessibleParent();
	if (ap instanceof AccessibleComponent) {
	return ((AccessibleComponent) ap).getCursor();
	} else {
	return null;
	}
	}
	}
	}

	public void setCursor(Cursor c) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setCursor(c);
	} else {
	Component cp = getCurrentComponent();
	if (cp != null) {
	cp.setCursor(c);
	}
	}
	}

	public Font getFont() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getFont();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.getFont();
	} else {
	return null;
	}
	}
	}

	public void setFont(Font f) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setFont(f);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.setFont(f);
	}
	}
	}

	public FontMetrics getFontMetrics(Font f) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getFontMetrics(f);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.getFontMetrics(f);
	} else {
	return null;
	}
	}
	}

	public boolean isEnabled() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).isEnabled();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.isEnabled();
	} else {
	return false;
	}
	}
	}

	public void setEnabled(boolean b) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setEnabled(b);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.setEnabled(b);
	}
	}
	}

	public boolean isVisible() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).isVisible();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.isVisible();
	} else {
	return false;
	}
	}
	}

	public void setVisible(boolean b) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setVisible(b);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.setVisible(b);
	}
	}
	}

	public boolean isShowing() {
	if (isVisible() && JTableHeader.this.isShowing()) {
	return true;
	} else {
	return false;
	}
	}

	public boolean contains(Point p) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	Rectangle r = ((AccessibleComponent) ac).getBounds();
	return r.contains(p);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	Rectangle r = c.getBounds();
	return r.contains(p);
	} else {
	return getBounds().contains(p);
	}
	}
	}

	public Point getLocationOnScreen() {
	if (parent != null) {
	Point parentLocation = parent.getLocationOnScreen();
	Point componentLocation = getLocation();
	componentLocation.translate(parentLocation.x, parentLocation.y);
	return componentLocation;
	} else {
	return null;
	}
	}

	public Point getLocation() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	Rectangle r = ((AccessibleComponent) ac).getBounds();
	return r.getLocation();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	Rectangle r = c.getBounds();
	return r.getLocation();
	} else {
	return getBounds().getLocation();
	}
	}
	}

	public void setLocation(Point p) {
	// if ((parent != null) && (parent.contains(p))) {
	// ensureIndexIsVisible(indexInParent);
	// }
	}

	public Rectangle getBounds() {
	Rectangle r = table.getCellRect(-1, column, false);
	r.y = 0;
	return r;

	// AccessibleContext ac = getCurrentAccessibleContext();
	// if (ac instanceof AccessibleComponent) {
	// return ((AccessibleComponent) ac).getBounds();
	// } else {
	// Component c = getCurrentComponent();
	// if (c != null) {
	// return c.getBounds();
	// } else {
	// Rectangle r = table.getCellRect(-1, column, false);
	// r.y = 0;
	// return r;
	// }
	// }
	}

	public void setBounds(Rectangle r) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setBounds(r);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.setBounds(r);
	}
	}
	}

	public Dimension getSize() {
	return getBounds().getSize();
	// AccessibleContext ac = getCurrentAccessibleContext();
	// if (ac instanceof AccessibleComponent) {
	// Rectangle r = ((AccessibleComponent) ac).getBounds();
	// return r.getSize();
	// } else {
	// Component c = getCurrentComponent();
	// if (c != null) {
	// Rectangle r = c.getBounds();
	// return r.getSize();
	// } else {
	// return getBounds().getSize();
	// }
	// }
	}

	public void setSize (Dimension d) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).setSize(d);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.setSize(d);
	}
	}
	}

	public Accessible getAccessibleAt(Point p) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).getAccessibleAt(p);
	} else {
	return null;
	}
	}

	public boolean isFocusTraversable() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	return ((AccessibleComponent) ac).isFocusTraversable();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	return c.isFocusTraversable();
	} else {
	return false;
	}
	}
	}

	public void requestFocus() {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).requestFocus();
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.requestFocus();
	}
	}
	}

	public void addFocusListener(FocusListener l) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).addFocusListener(l);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.addFocusListener(l);
	}
	}
	}

	public void removeFocusListener(FocusListener l) {
	AccessibleContext ac = getCurrentAccessibleContext();
	if (ac instanceof AccessibleComponent) {
	((AccessibleComponent) ac).removeFocusListener(l);
	} else {
	Component c = getCurrentComponent();
	if (c != null) {
	c.removeFocusListener(l);
	}
	}
	}

	} // inner class AccessibleJTableHeaderElement

	} // inner class AccessibleJTableHeader

	} // End of Class JTableHeader

Back to index...