JXTable's
* columns.
* It's main purpose is to allow toggling of table columns' visibility.
* Additionally, arbitrary configuration actions can be exposed.
*
*
* This component is installed in the JXTable's
* trailing corner, if enabled:
*
*
* table.setColumnControlVisible(true);
* JXTable, the component's behaviour is
* opaque. Typically, the button's action is to popup a component for user
* interaction.
*
* This class is responsible for handling/providing/updating the lists of
* actions and to keep all action's state in synch with Table-/Column state.
* The visible behaviour of the popup is delegated to a
* ColumnControlPopup.
*
* @see TableColumnExt
* @see TableColumnModelExt
* @see JXTable#setColumnControl
*
*/
public class ColumnControlButton extends JButton {
// JW: really want to extend? for builders?
/** Marker to auto-recognize actions which should be added to the popup. */
public static final String COLUMN_CONTROL_MARKER = "column.";
/** the key for looking up the control's icon in the UIManager. Typically, it's LAF dependent. */
public static final String COLUMN_CONTROL_BUTTON_ICON_KEY = "ColumnControlButton.actionIcon";
/** the key for looking up the control's margin in the UIManager. Typically, it's LAF dependent. */
public static final String COLUMN_CONTROL_BUTTON_MARGIN_KEY = "ColumnControlButton.margin";
static {
LookAndFeelAddons.contribute(new ColumnControlButtonAddon());
}
/** exposed for testing. */
protected ColumnControlPopup popup;
// TODO: the table reference is a potential leak?
/** The table which is controlled by this. */
private JXTable table;
/** Listener for table property changes. */
private PropertyChangeListener tablePropertyChangeListener;
/** Listener for table's columnModel. */
TableColumnModelListener columnModelListener;
/** the list of actions for column menuitems.*/
private List
*
* Here: delegates to getControlPopup().
*/
public void togglePopup() {
getColumnControlPopup().toggleVisibility(this);
}
@Override
public void applyComponentOrientation(ComponentOrientation o) {
super.applyComponentOrientation(o);
getColumnControlPopup().applyComponentOrientation(o);
}
//-------------------------- Action in synch with column properties
/**
* A specialized
* Implementation note: this listener reacts to column's
*
* PRE: columnVisibilityActions populated before calling this.
*
*/
protected void addVisibilityActionItems() {
getColumnControlPopup().addVisibilityActionItems(
Collections.unmodifiableList(getColumnVisibilityActions()));
}
/**
* Adds additional actions to the popup.
* Here: delegates the list of actions as returned by #getAdditionalActions()
* to the DefaultColumnControlPopup.
* Does nothing if #getColumnActions() is empty.
*
*/
protected void addAdditionalActionItems() {
getColumnControlPopup().addAdditionalActionItems(
Collections.unmodifiableList(getAdditionalActions()));
}
/**
* Creates and adds a ColumnVisiblityAction for every column that should be
* togglable via the column control.
*
* Here: all table columns contained in the
* PRE: canControl()
*
* @see #createColumnVisibilityAction
*/
protected void createVisibilityActions() {
List
* Implementation note: this listener reacts to table's
* Implementation note: this listener reacts to "real" columnRemoved/-Added by
* populating the popups content from scratch.
*
* @return the JXTable controlled by this component
*/
public ColumnControlButton(JXTable table) {
this(table, null);
}
/**
* Creates a column control button for the table. The button
* uses the given icon and has no text.
* @param table the JXTable controlled by this component
* @param icon the Icon to show
*/
public ColumnControlButton(JXTable table, Icon icon) {
super();
init();
// JW: icon LF dependent?
setAction(createControlAction(icon));
updateActionUI();
updateButtonUI();
installTable(table);
}
@Override
public void updateUI() {
super.updateUI();
// JW: icon may be LF dependent
updateActionUI();
updateButtonUI();
getColumnControlPopup().updateUI();
}
/**
* Updates this button's properties provided by the LAF.
* Here: overwrites the action's small_icon with the icon from the ui if the current
* icon is null or a UIResource.
*/
protected void updateButtonUI() {
if ((getMargin() == null) || (getMargin() instanceof UIResource)) {
Insets insets = UIManager.getInsets(COLUMN_CONTROL_BUTTON_MARGIN_KEY);
setMargin(insets);
}
}
/**
* Updates the action properties provided by the LAF.
* Here: overwrites the action's small_icon with the icon from the ui if the current
* icon is null or a UIResource.
*/
protected void updateActionUI() {
if (getAction() == null) return;
Icon icon = (Icon) getAction().getValue(Action.SMALL_ICON);
if ((icon == null) || (icon instanceof UIResource)) {
icon = UIManager.getIcon(COLUMN_CONTROL_BUTTON_ICON_KEY);
getAction().putValue(Action.SMALL_ICON, icon);
}
}
/**
* Toggles the popup component's visibility. This method is
* called by this control's default action. Action which takes care of keeping in synch with
* TableColumn state.
*
* NOTE: client must call releaseColumn if this action is no longer needed!
*
*/
public class ColumnVisibilityAction extends AbstractActionExt {
private TableColumn column;
private PropertyChangeListener columnListener;
/** flag to distinguish selection changes triggered by
* column's property change from those triggered by
* user interaction. Hack around #212-swingx.
*/
private boolean fromColumn;
/**
* Creates a action synched to the table column.
*
* @param column the TableColumn to keep synched to.
*/
public ColumnVisibilityAction(TableColumn column) {
super((String) null);
setStateAction();
installColumn(column);
}
/**
* Releases all references to the synched TableColumn.
* Client code must call this method if the
* action is no longer needed. After calling this action must not be
* used any longer.
*/
public void releaseColumn() {
column.removePropertyChangeListener(columnListener);
column = null;
}
/**
* Returns true if the action is enabled. Returns
* true only if the action is enabled and the table
* column can be controlled.
*
* @return true if the action is enabled, false otherwise
* @see #canControlColumn()
*/
@Override
public boolean isEnabled() {
return super.isEnabled() && canControlColumn();
}
/**
* Returns flag to indicate if column's visibility can
* be controlled. Minimal requirement is that column is of type
* TableColumnExt.
*
* @return boolean to indicate if columns's visibility can be controlled.
*/
protected boolean canControlColumn() {
// JW: should have direction? control is from action to column, the
// other way round should be guaranteed always
return (column instanceof TableColumnExt);
}
@Override
public void itemStateChanged(final ItemEvent e) {
if (canControlColumn()) {
if ((e.getStateChange() == ItemEvent.DESELECTED)
//JW: guarding against 1 leads to #212-swingx: setting
// column visibility programatically fails if
// the current column is the second last visible
// guarding against 0 leads to hiding all columns
// by deselecting the menu item.
&& (table.getColumnCount() <= 1)
// JW Fixed #212: basically implemented Rob's idea to distinguish
// event sources instead of unconditionally reselect
// not entirely sure if the state transitions are completely
// defined but all related tests are passing now.
&& !fromColumn) {
reselect();
} else {
setSelected(e.getStateChange() == ItemEvent.SELECTED);
}
}
}
@Override
public synchronized void setSelected(boolean newValue) {
super.setSelected(newValue);
if (canControlColumn()) {
((TableColumnExt) column).setVisible(newValue);
}
}
/**
* Does nothing. Synch from action state to TableColumn state
* is done in itemStateChanged.
*/
public void actionPerformed(ActionEvent e) {
}
/**
* Synchs selected property to visible. This
* is called on change of tablecolumn's visible property.
*
* @param visible column visible state to synch to.
*/
private void updateFromColumnVisible(boolean visible) {
// /*boolean*/ visible = true;
// if (canControlColumn()) {
// visible = ((TableColumnExt) column).isVisible();
// }
fromColumn = true;
setSelected(visible);
fromColumn = false;
}
/**
* Synchs name property to value. This is called on change of
* tableColumn's headerValue property.
*
* @param value
*/
private void updateFromColumnHeader(Object value) {
setName(String.valueOf(value));
}
/**
* Enforces selected to true. Called if user interaction
* tried to de-select the last single visible column.
*
*/
private void reselect() {
firePropertyChange("selected", null, Boolean.TRUE);
}
// -------------- init
private void installColumn(TableColumn column) {
this.column = column;
column.addPropertyChangeListener(getColumnListener());
updateFromColumnHeader(column.getHeaderValue());
// #429-swing: actionCommand must be string
if (column.getIdentifier() != null) {
setActionCommand(column.getIdentifier().toString());
}
boolean visible = (column instanceof TableColumnExt) ?
((TableColumnExt) column).isVisible() : true;
updateFromColumnVisible(visible);
}
/**
* Returns the listener to column's property changes. The listener
* is created lazily if necessary.
*
* @return the PropertyChangeListener listening to
* TableColumn's property changes, guaranteed to be
* not null.
*/
protected PropertyChangeListener getColumnListener() {
if (columnListener == null) {
columnListener = createPropertyChangeListener();
}
return columnListener;
}
/**
* Creates and returns the listener to column's property changes.
* Subclasses are free to roll their own.
* visible and headerValue properties and
* calls the respective updateFromXX methodes.
*
* @return the PropertyChangeListener to use with the
* column
*/
protected PropertyChangeListener createPropertyChangeListener() {
return new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
if ("visible".equals(evt.getPropertyName())) {
updateFromColumnVisible((Boolean) evt.getNewValue());
} else if ("headerValue".equals(evt.getPropertyName())) {
updateFromColumnHeader(evt.getNewValue());
}
}
};
}
}
// ---------------------- the popup
/**
* A default implementation of ColumnControlPopup.
* It uses a JPopupMenu with
* MenuItems corresponding to the Actions as
* provided by the ColumnControlButton.
*
*
*/
public class DefaultColumnControlPopup implements ColumnControlPopup {
private JPopupMenu popupMenu;
//------------------ public methods to control visibility status
/**
* @inheritDoc
*
*/
public void updateUI() {
SwingUtilities.updateComponentTreeUI(getPopupMenu());
}
/**
* @inheritDoc
*
*/
public void toggleVisibility(JComponent owner) {
JPopupMenu popupMenu = getPopupMenu();
if (popupMenu.isVisible()) {
popupMenu.setVisible(false);
} else if (popupMenu.getComponentCount() > 0) {
Dimension buttonSize = owner.getSize();
int xPos = owner.getComponentOrientation().isLeftToRight() ? buttonSize.width
- popupMenu.getPreferredSize().width
: 0;
popupMenu.show(owner,
// JW: trying to allow popup without CCB showing
// weird behaviour
// owner.isShowing()? owner : null,
xPos, buttonSize.height);
}
}
/**
* @inheritDoc
*
*/
public void applyComponentOrientation(ComponentOrientation o) {
getPopupMenu().applyComponentOrientation(o);
}
//-------------------- public methods to manipulate popup contents.
/**
* @inheritDoc
*
*/
public void removeAll() {
getPopupMenu().removeAll();
}
/**
* @inheritDoc
*
*/
public void addVisibilityActionItems(
List actions) {
addItems(new ArrayListnull.
* @see #createColumnControlPopup()
*/
protected ColumnControlPopup getColumnControlPopup() {
if (popup == null) {
popup = createColumnControlPopup();
}
return popup;
}
/**
* Factory method to return a ColumnControlPopup.
* Subclasses can override to hook custom implementations.
*
* @return the ColumnControlPopup used.
*/
protected ColumnControlPopup createColumnControlPopup() {
return new DefaultColumnControlPopup();
}
//-------------------------- updates from table propertyChangelistnere
/**
* Adjusts internal state after table's column model property has changed.
* Handles cleanup of listeners to the old/new columnModel (Note, that
* it listens to the column model only if it can control column visibility).
* Updates content of popup.
*
* @param oldModel the old TableColumnModel we had been listening to.
*/
protected void updateFromColumnModelChange(TableColumnModel oldModel) {
if (oldModel != null) {
oldModel.removeColumnModelListener(columnModelListener);
}
populatePopup();
if (canControl()) {
table.getColumnModel().addColumnModelListener(getColumnModelListener());
}
}
/**
* Synchs this button's enabled with table's enabled.
*
*/
protected void updateFromTableEnabledChanged() {
getAction().setEnabled(table.isEnabled());
}
/**
* Method to check if we can control column visibility POST: if true we can
* be sure to have an extended TableColumnModel
*
* @return boolean to indicate if controlling the visibility state is
* possible.
*/
protected boolean canControl() {
return table.getColumnModel() instanceof TableColumnModelExt;
}
// ------------------------ updating the popup
/**
* Populates the popup from scratch.
*
* If applicable, creates and adds column visibility actions. Always adds
* additional actions.
*/
protected void populatePopup() {
clearAll();
if (canControl()) {
createVisibilityActions();
addVisibilityActionItems();
}
addAdditionalActionItems();
}
/**
*
* removes all components from the popup, making sure to release all
* columnVisibility actions.
*
*/
protected void clearAll() {
clearColumnVisibilityActions();
getColumnControlPopup().removeAll();
}
/**
* Releases actions and clears list of actions.
*
*/
protected void clearColumnVisibilityActions() {
if (columnVisibilityActions == null)
return;
for (ColumnVisibilityAction action : columnVisibilityActions) {
action.releaseColumn();
}
columnVisibilityActions.clear();
}
/**
* Adds visibility actions into the popup view.
*
* Here: delegates the list of actions to the DefaultColumnControlPopup.
* TableColumnModel -
* visible and invisible columns - to createColumnVisibilityAction and
* adds all not null return values.
*
* ColumnVisibilityAction for the given
* TableColumn. The return value might be null, f.i. if the
* column should not be allowed to be toggled.
*
* @param column the TableColumn to use for the action
* @return a ColumnVisibilityAction to use for the given column,
* may be null.
*/
protected ColumnVisibilityAction createColumnVisibilityAction(TableColumn column) {
return new ColumnVisibilityAction(column);
}
/**
* Lazyly creates and returns the List of visibility actions.
*
* @return the list of visibility actions, guaranteed to be != null.
*/
protected ListPropertyChangeListener for use with the
* table, guaranteed to be not null.
*/
protected PropertyChangeListener getTablePropertyChangeListener() {
if (tablePropertyChangeListener == null) {
tablePropertyChangeListener = createTablePropertyChangeListener();
}
return tablePropertyChangeListener;
}
/**
* Creates the listener to table's property changes. Subclasses are free
* to roll their own. enabled and
* columnModel properties and calls the respective
* updateFromXX methodes.
*
* @return the PropertyChangeListener for use with the table.
*/
protected PropertyChangeListener createTablePropertyChangeListener() {
return new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
if ("columnModel".equals(evt.getPropertyName())) {
updateFromColumnModelChange((TableColumnModel) evt
.getOldValue());
} else if ("enabled".equals(evt.getPropertyName())) {
updateFromTableEnabledChanged();
}
}
};
}
/**
* Returns the listener to table's column model. The listener is
* lazily created if necessary.
* @return the TableColumnModelListener for use with the
* table's column model, guaranteed to be not null.
*/
protected TableColumnModelListener getColumnModelListener() {
if (columnModelListener == null) {
columnModelListener = createColumnModelListener();
}
return columnModelListener;
}
/**
* Creates the listener to columnModel. Subclasses are free to roll their
* own.
* TableColumnModelListener for use with the
* table's columnModel.
*/
protected TableColumnModelListener createColumnModelListener() {
return new TableColumnModelListener() {
/** Tells listeners that a column was added to the model. */
public void columnAdded(TableColumnModelEvent e) {
// quickfix for #192
if (!isVisibilityChange(e, true)) {
populatePopup();
}
}
/** Tells listeners that a column was removed from the model. */
public void columnRemoved(TableColumnModelEvent e) {
if (!isVisibilityChange(e, false)) {
populatePopup();
}
}
/**
* Check if the add/remove event is triggered by a move to/from the
* invisible columns.
*
* PRE: the event must be received in columnAdded/Removed.
*
* @param e the received event
* @param added if true the event is assumed to be received via
* columnAdded, otherwise via columnRemoved.
* @return boolean indicating whether the removed/added is a side-effect
* of hiding/showing the column.
*/
private boolean isVisibilityChange(TableColumnModelEvent e,
boolean added) {
// can't tell
if (!(e.getSource() instanceof DefaultTableColumnModelExt))
return false;
DefaultTableColumnModelExt model = (DefaultTableColumnModelExt) e
.getSource();
if (added) {
return model.isAddedFromInvisibleEvent(e.getToIndex());
} else {
return model.isRemovedToInvisibleEvent(e.getFromIndex());
}
}
/** Tells listeners that a column was repositioned. */
public void columnMoved(TableColumnModelEvent e) {
}
/** Tells listeners that a column was moved due to a margin change. */
public void columnMarginChanged(ChangeEvent e) {
}
/**
* Tells listeners that the selection model of the TableColumnModel
* changed.
*/
public void columnSelectionChanged(ListSelectionEvent e) {
}
};
}
} // end class ColumnControlButton