/*******************************************************************************
* Mission Control Technologies, Copyright (c) 2009-2012, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* The MCT platform is licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* MCT includes source code licensed under additional open source licenses. See
* the MCT Open Source Licenses file included with this distribution or the About
* MCT Licenses dialog available at runtime from the MCT Help menu for additional
* information.
*******************************************************************************/
/**
*
*/
package gov.nasa.arc.mct.table.view;
import gov.nasa.arc.mct.abbreviation.AbbreviationService;
import gov.nasa.arc.mct.abbreviation.Abbreviations;
import gov.nasa.arc.mct.components.AbstractComponent;
import gov.nasa.arc.mct.components.FeedProvider;
import gov.nasa.arc.mct.components.FeedProvider.FeedType;
import gov.nasa.arc.mct.evaluator.api.Evaluator;
import gov.nasa.arc.mct.table.access.ServiceAccess;
import gov.nasa.arc.mct.table.gui.LabeledTable;
import gov.nasa.arc.mct.table.model.ComponentTableModel;
import gov.nasa.arc.mct.table.model.LabeledTableModel;
import gov.nasa.arc.mct.table.model.TableColumnModelAdapter;
import gov.nasa.arc.mct.table.model.TableOrientation;
import gov.nasa.arc.mct.table.model.TableType;
import gov.nasa.arc.mct.table.view.BorderState.BorderEdge;
import gov.nasa.arc.mct.table.view.TableFormattingConstants.JVMFontFamily;
import gov.nasa.arc.mct.table.view.TimeFormat.DateFormatItem;
import java.awt.Color;
import java.awt.Font;
import java.util.HashSet;
import java.util.Iterator;
import java.util.ResourceBundle;
import java.util.Set;
import javax.swing.ButtonModel;
import javax.swing.ComboBoxModel;
import javax.swing.DefaultComboBoxModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.TableColumn;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Implements a controller that mediates between a labeled table and
* a control panel for that table.
*/
public class TableControlPanelController extends TableSettingsController {
private static final Logger logger = LoggerFactory.getLogger(TableControlPanelController.class);
/** The resource bundle we should use for getting strings. */
private static final ResourceBundle bundle = ResourceBundle.getBundle("TableSettingsControlPanel"); //NOI18N
private LabeledTable table;
private LabeledTableModel model;
private TableViewManifestation manifestation;
/**
* Creates a new controller for a view, table, and table model.
*
* @param manifestation the table view manifestation
* @param table the table
* @param model the table model
*/
public TableControlPanelController(TableViewManifestation manifestation, LabeledTable table, LabeledTableModel model) {
this.manifestation = manifestation;
this.table = table;
this.model = model;
table.getTable().getSelectionModel().addListSelectionListener(new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
TableControlPanelController.this.fireSelectionChanged();
}
});
table.getTable().getColumnModel().addColumnModelListener(new TableColumnModelAdapter() {
@Override
public void columnSelectionChanged(ListSelectionEvent e) {
TableControlPanelController.this.fireSelectionChanged();
}
});
table.getRowHeaders().addListSelectionListener(new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
TableControlPanelController.this.fireSelectionChanged();
}
});
}
@Override
public boolean getShowGrid() {
return table.getTable().getShowHorizontalLines();
}
@Override
public TableOrientation getTableOrientation() {
return model.getOrientation();
}
@Override
public void setShowGrid(boolean showGrid) {
table.setShowGrid(showGrid);
manifestation.saveCellSettings();
}
@Override
public void setTableOrientation(TableOrientation orientation) {
model.setOrientation(orientation);
manifestation.swapAbbreviationsUponTableOrientationChange(orientation);
table.updateColumnsHeaderValuesOnly();
table.updateDropMode();
manifestation.saveCellSettingsUponTableOrientationChange();
for (int row = 0; row < table.getTable().getRowCount(); row++) {
table.getTable().setRowHeight(row, getRowHeightFromPersistence(row));
}
}
@Override
public void transposeTable() {
logger.error("Should transpose the table.");
}
@Override
public int getSelectedCellCount() {
return getSelectedRowCount() * getSelectedColumnCount();
}
@Override
public int getSelectedColumnCount() {
if (model.isSkeleton()) {
return 0;
} else if (model.getTableType() == TableType.ZERO_DIMENSIONAL) {
// We have to special-case a 0-D table since the
// row or column selection might be zero while the other
// is nonzero.
return (table.getTable().isCellSelected(0, 0) ? 1 : 0);
} else {
return table.getTable().getSelectedColumnCount();
}
}
@Override
public int getSelectedRowCount() {
if (model.isSkeleton()) {
return 0;
} else if (model.getTableType() == TableType.ZERO_DIMENSIONAL) {
// We have to special-case a 0-D table since the
// row or column selection might be zero while the other
// is nonzero.
return (table.getTable().isCellSelected(0, 0) ? 1 : 0);
} else {
return table.getTable().getSelectedRowCount();
}
}
@Override
public boolean isCanHideHeaders() {
return true;
}
@Override
public int getColumnWidth() {
if (getSelectedColumnCount() == 0) {
return -1;
} else {
int firstColumn = table.getTable().getColumnModel().getSelectedColumns()[0];
return table.getTable().getColumnModel().getColumn(firstColumn).getPreferredWidth();
}
}
private int getRowHeightFromPersistence(int rowIndex) {
int rowHeight = table.getTable().getRowHeight();
TableSettings tableSettings = manifestation.loadSettingsFromPersistence();
for (TableSettings.AvailableSettings setting : TableSettings.AvailableSettings
.values()) {
try {
String name = setting.name();
String value = manifestation.getViewProperties().getProperty(name, String.class);
if (name.equals(TableSettings.AvailableSettings.ROW_HEIGHTS.name())) {
if ((value != null) && !value.isEmpty()) {
int[] rowHeights = tableSettings.toIntegerArray(value);
return rowHeights[rowIndex];
}
}
} catch (Exception ex) {
logger.error("Exception when loading persistent settings: ", ex);
}
}
return rowHeight;
}
@Override
public int getRowHeight() {
int[] selectedRows = table.getTable().getSelectedRows();
if (selectedRows == null || selectedRows.length == 0) {
return -1;
}
int firstRowHeight = -1;
for (int i = 0; i < selectedRows.length; i++) {
int currentRowHeight = getRowHeightFromPersistence(selectedRows[i]);
if (currentRowHeight > 0) {
if (i == 0) {
firstRowHeight = currentRowHeight;
}
setRowHeight(selectedRows[i], currentRowHeight);
}
}
return firstRowHeight;
}
/* @Override
public Integer getRowHeight() {
Integer commonSize = null;
for (Integer row : table.getSelectedRows()) {
Integer aSize = table.getRowHeight(row);
if (commonSize!=null && commonSize!=aSize) {
return null;
}
commonSize = aSize;
}
return commonSize;
}*/
@Override
public void setColumnWidth(int newWidth) {
for (int col : table.getTable().getSelectedColumns()) {
TableColumn column = table.getTable().getColumnModel().getColumn(col);
if (column.getPreferredWidth() != newWidth) {
column.setPreferredWidth(newWidth);
}
}
manifestation.saveCellSettings();
}
@Override
public void setRowHeight(int newHeight) {
for (int row : table.getTable().getSelectedRows()) {
if (table.getTable().getRowHeight(row) != newHeight) {
table.setRowHeight(row, newHeight);
table.getTable().setRowHeight(row, newHeight);
}
}
manifestation.saveCellSettings();
}
private void setRowHeight(int rowIndex, int newHeight) {
if (table.getTable().getRowHeight(rowIndex) != newHeight) {
table.getTable().setRowHeight(rowIndex, newHeight);
manifestation.saveCellSettings();
}
}
/**
* Tests whether a single, non-empty cell has been selected. If a single
* cell selection exists, return true if the cell has a component at that
* location.
*
* @return true, if a single, non-empty cell has been selected, false otherwise
*/
public boolean isSingleCellSelection() {
if (getSelectedCellCount() != 1) {
return false;
} else {
return !isSelectionContainsEmptyCells();
}
}
private boolean isSelectionContainsEmptyCells() {
for (int row : table.getSelectedRows()) {
for (int column : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, column);
if (component == null) {
return true;
}
}
}
return false;
}
@Override
public ComboBoxModel getEnumerationModel() {
DefaultComboBoxModel enumerationModel = new DefaultComboBoxModel();
if (isSelectionContainsEmptyCells()) {
enumerationModel.addElement(new EnumerationItem(null));
return enumerationModel;
}
if (isSingleCellSelection()) {
EnumerationItem selectedItem = null;
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
TableCellSettings cellSettings = tableModel.getCellSettings(tableModel.getKey(component));
AbstractComponent evaluator = cellSettings.getEvaluator();
//Enumeration control is now always visible, so show None as option
enumerationModel.addElement(new EnumerationItem(null));
// Add the component itself, if it can be a self-evaluator.
if (component.getCapability(Evaluator.class) != null && !component.getCapability(Evaluator.class).requiresMultipleInputs()) {
EnumerationItem item = new EnumerationItem(component);
enumerationModel.addElement(item);
if (evaluator!=null && evaluator.getId().equals(component.getId())) {
selectedItem = item;
}
}
AbstractComponent referencedComponent = component;
for (AbstractComponent parent : referencedComponent.getReferencingComponents()) {
// For now, we only find evaluators that have exactly one child (the current component).
Evaluator e = parent.getCapability(Evaluator.class);
if (e != null && !e.requiresMultipleInputs()) {
// Found an evaluator for the component.
EnumerationItem item = new EnumerationItem(parent);
enumerationModel.addElement(item);
if (evaluator!=null && evaluator.getId().equals(parent.getId())) {
selectedItem = item;
}
}
}
if (selectedItem != null) {
enumerationModel.setSelectedItem(selectedItem);
}
} else {
addCommonEnumerators(enumerationModel);
}
return enumerationModel;
}
/** Find all common (i.e., intersection of) enumerators for selected cells
* @param enumerationModel
*/
private void addCommonEnumerators(DefaultComboBoxModel enumerationModel) {
if (getSelectedCellCount() > 0) {
Set<EnumerationItem> commonEnums = new HashSet<EnumerationItem>();
AbstractComponent commonSelectedEvaluator = null;
boolean commonEvaluator = true;
boolean mixedEvaluatorSet = false;
boolean firstCell = true;
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
// Enumeration control is always showing, so add None as option
EnumerationItem none = new EnumerationItem(null);
enumerationModel.addElement(none);
enumerationModel.setSelectedItem(none);
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
AbstractComponent referencedComponent = component;
// Add the component itself, if it can be a self-evaluator.
if (referencedComponent.getCapability(Evaluator.class) != null &&
!referencedComponent.getCapability(Evaluator.class).requiresMultipleInputs()) {
EnumerationItem item = new EnumerationItem(referencedComponent);
enumerationModel.addElement(item);
}
for (AbstractComponent parent : referencedComponent.getReferencingComponents()) {
// For now, we only find evaluators that have exactly one child (the current component).
Evaluator e = parent.getCapability(Evaluator.class);
if (e != null && !e.requiresMultipleInputs()) {
// Found an enumeration for the component.
commonEnums.add(new EnumerationItem(parent));
}
}
for (int row : table.getSelectedRows()) {
for (int column : table.getSelectedColumns()) {
component = (AbstractComponent) model.getStoredValueAt(row, column);
if (component == null) {
mixedEvaluatorSet = true;
continue;
}
referencedComponent = component;
TableCellSettings cellSettings = tableModel.getCellSettings(tableModel.getKey(referencedComponent));
AbstractComponent evaluator = cellSettings.getEvaluator();
if (commonSelectedEvaluator != null)
if (evaluator != null) {
if (!evaluator.getId().equals(commonSelectedEvaluator.getId())) {
mixedEvaluatorSet = true;
}
} else {
mixedEvaluatorSet = true;
} else {
if (evaluator != null && !firstCell) {
mixedEvaluatorSet = true;
}
}
if (!mixedEvaluatorSet) {
commonSelectedEvaluator = evaluator;
}
firstCell = false;
Iterator<EnumerationItem> iterator = commonEnums.iterator();
while (iterator.hasNext()) {
EnumerationItem commonEnum = iterator.next();
if (!commonEnum.getEvaluator().getComponents().contains(referencedComponent)) {
iterator.remove();
}
}
}
}
Iterator<EnumerationItem> iterator = commonEnums.iterator();
while (iterator.hasNext()) {
EnumerationItem nextItem = iterator.next();
enumerationModel.addElement(nextItem);
if (!mixedEvaluatorSet && nextItem.getEvaluator().equals(commonSelectedEvaluator)) {
enumerationModel.setSelectedItem(nextItem);
}
}
}
}
/** Determine whether or not all selected cells have the same evaluator or not
* @return true if all the selected cells do not have the same evaluator
*/
@Override
public boolean selectedCellsHaveMixedEnumerations() {
AbstractComponent commonSelectedEvaluator = null;
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
boolean firstCell = true;
for (int row : table.getSelectedRows()) {
for (int column : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, column);
if (component == null) {
return true;
}
AbstractComponent referencedComponent = component;
TableCellSettings cellSettings = tableModel.getCellSettings(tableModel.getKey(referencedComponent));
AbstractComponent evaluator = cellSettings.getEvaluator();
if (commonSelectedEvaluator != null)
if (evaluator != null) {
if (!evaluator.getId().equals(commonSelectedEvaluator.getId())) {
return true;
}
} else {
return true;
} else {
if (evaluator != null && !firstCell) {
return true;
}
}
commonSelectedEvaluator = evaluator;
firstCell = false;
}
}
return false;
}
@Override
public void setEnumeration(ComboBoxModel comboBoxModel) {
if (isSingleCellSelection()) {
TableCellSettings settings = getTableCellSettings(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
settings.setEvaluator(EnumerationItem.class.cast(comboBoxModel.getSelectedItem()).getEvaluator());
manifestation.saveCellSettings();
} else {
for (Integer row : table.getSelectedRows()) {
for (Integer column : table.getSelectedColumns()) {
TableCellSettings settings = getTableCellSettings(row, column);
settings.setEvaluator(EnumerationItem.class.cast(comboBoxModel.getSelectedItem()).getEvaluator());
}
}
manifestation.saveCellSettings();
}
}
@Override
public boolean enumerationIsNone(ComboBoxModel model) {
if (model.getSelectedItem() == null || //Mixed enum state
(model.getSelectedItem() != null && // an enum is selected/set
EnumerationItem.class.cast(model.getSelectedItem()).getEvaluator() != null)) {
return false; //nothing is selected
}
return (EnumerationItem.class.cast(model.getSelectedItem()).getEvaluator() == null);
}
@Override
public boolean dateIsNone(ComboBoxModel model) {
if (DateFormatItem.None == model.getSelectedItem()) {
return true;
}
return false;
}
@Override
public boolean showDecimalPlaces() {
if (isSelectionContainsEmptyCells()) {
return false;
}
if (table.getSelectedRows().length == 0 && table.getSelectedColumns().length == 0) {
return false;
}
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
FeedProvider fp = component.getCapability(FeedProvider.class);
if (fp == null || fp.getFeedType() == FeedType.STRING) {
return false;
}
}
}
return true;
}
@Override
public Integer getDecimalPlaces() {
if (isSelectionContainsEmptyCells()) {
return null;
}
Integer decimalPlaces = null;
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
int decimals = settings.getNumberOfDecimals();
// determine default decimal places
if (decimals == -1) {
FeedProvider fp = component.getCapability(FeedProvider.class);
if (fp != null) {
decimals = fp.getFeedType() == FeedType.INTEGER ? 0 : TableCellSettings.DEFAULT_DECIMALS;
}
}
if (decimalPlaces != null && decimalPlaces != decimals) {
return null;
}
decimalPlaces = decimals;
}
}
return decimalPlaces;
}
@Override
public JVMFontFamily getCellFontName() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return settings.getCellFont();
}
JVMFontFamily defaultFont = TableFormattingConstants.defaultJVMFontFamily;
JVMFontFamily commonCellFont = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
JVMFontFamily aCellFont = settings.getCellFont();
if (aCellFont == null) {
aCellFont = defaultFont;
}
if (commonCellFont != null && !aCellFont.equals(commonCellFont)) {
return null;
}
commonCellFont = aCellFont;
}
}
return commonCellFont;
}
@Override
public Integer getCellFontSize() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return Integer.valueOf(settings.getFontSize());
}
Integer defaultFontSize = Integer.valueOf(TableFormattingConstants.defaultFontSize);
Integer commonCellFontSize = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
Integer aCellFontSize = settings.getFontSize();
// determine default decimal places
if (aCellFontSize == null) {
aCellFontSize = defaultFontSize;
}
if (commonCellFontSize != null && !aCellFontSize.equals(commonCellFontSize)) {
return null;
}
commonCellFontSize = aCellFontSize;
}
}
return commonCellFontSize;
}
@Override
public Color getCellFontColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return settings.getFontColor();
}
Color commonCellColor = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
Color aCellFontColor = settings.getFontColor();
if ((commonCellColor != null && !commonCellColor.equals(aCellFontColor))) {
return null;
}
commonCellColor = aCellFontColor;
}
}
return commonCellColor;
}
@Override
public Color getCellBackgroundColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return settings.getBackgroundColor();
}
Color commonCellColor = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
Color aCellBackgroundColor = settings.getBackgroundColor();
if (commonCellColor != null && !commonCellColor.equals(aCellBackgroundColor)) {
return null;
}
commonCellColor = aCellBackgroundColor;
}
}
return commonCellColor;
}
@Override
public Integer getCellFontStyle() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return Integer.valueOf(settings.getFontStyle());
}
Integer defaultFontStyle = TableFormattingConstants.defaultFontStyle;
Integer commonCellFontStyle = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
Integer aCellFontStyle = settings.getFontStyle();
// determine default decimal places
if (aCellFontStyle == null) {
aCellFontStyle = defaultFontStyle;
}
if (commonCellFontStyle != null && !aCellFontStyle.equals(commonCellFontStyle)) {
return null;
}
commonCellFontStyle = aCellFontStyle;
}
}
return commonCellFontStyle;
}
@Override
public Integer getCellFontTextAttribute() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
if (isSingleCellSelection()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return Integer.valueOf(settings.getTextAttributeUnderline());
}
Integer defaultFontTextAttribute = TableFormattingConstants.UNDERLINE_OFF;
Integer commonCellFontTextAttribute = null;
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
Integer aCellFontTextAttribute = settings.getTextAttributeUnderline();
// determine default decimal places
if (aCellFontTextAttribute == null) {
aCellFontTextAttribute = defaultFontTextAttribute;
}
if (commonCellFontTextAttribute != null && !aCellFontTextAttribute.equals(commonCellFontTextAttribute)) {
return null;
}
commonCellFontTextAttribute = aCellFontTextAttribute;
}
}
return commonCellFontTextAttribute;
}
@Override
public void setDecimalPlaces(ComboBoxModel comboBoxModel) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setNumberOfDecimals(Integer.class.cast(comboBoxModel.getSelectedItem()).intValue());
}
}
tableModel.updateDecimalsForColumns();
manifestation.saveCellSettings();
}
@Override
public void setCellFont(ComboBoxModel comboBoxModel) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setCellFont(JVMFontFamily.class.cast(comboBoxModel.getSelectedItem()));
}
}
manifestation.saveCellSettings();
}
@Override
public void setCellFontColor(Color fontColor) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setForegroundColor(fontColor);
}
}
manifestation.saveCellSettings();
}
@Override
public void setCellBackgroundColor(Color backgroundColor) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setBackgroundColor(backgroundColor);
}
}
manifestation.saveCellSettings();
}
@Override
public void setCellFontSize(int fontSize) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setFontSize(fontSize);
}
}
manifestation.saveCellSettings();
}
@Override
public void setCellFontStyle(int fontStyle) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setFontStyle(fontStyle);
}
}
manifestation.saveCellSettings();
}
@Override
public void setCellFontTextAttribute(int fontStyle) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
settings.setTextAttributeUnderline(fontStyle);
}
}
manifestation.saveCellSettings();
}
@Override
public DateFormatItem getDateFormat() {
if (isSelectionContainsEmptyCells()) {
return null;
}
DateFormatItem df = null;
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
DateFormatItem cellDateFormat = settings.getDateFormat();
df = cellDateFormat;
}
}
return df;
}
@Override
public void setDateFormat(ComboBoxModel comboBoxModel) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
DateFormatItem df = (DateFormatItem)comboBoxModel.getSelectedItem();
settings.setDateFormat(df);
}
}
manifestation.saveCellSettings();//persistDate
}
private TableCellSettings getTableCellSettings(int rowIndex, int columnIndex) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(rowIndex, columnIndex);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
return settings;
}
private static class EnumerationItem implements Comparable<EnumerationItem> {
private AbstractComponent evaluator;
private String evalID = "";
public EnumerationItem(AbstractComponent enumeration) {
this.evaluator = enumeration;
if (evaluator != null) {
this.evalID = evaluator.getComponentId();
}
}
@Override
public String toString() {
if (evaluator == null) {
return bundle.getString("ENUMERATION_NONE");
} else {
return evaluator.getDisplayName() + " (" + evaluator.getCapability(Evaluator.class).getLanguage() + ")";
}
}
public AbstractComponent getEvaluator() {
return evaluator;
}
@Override
public boolean equals(Object other) {
boolean result = false;
if (other instanceof EnumerationItem) {
EnumerationItem that = (EnumerationItem) other;
result = (this.evalID.equals(that.evalID) && super.equals(that));
}
return result;
}
@Override public int hashCode() {
return this.evalID.hashCode();
}
@Override
public int compareTo(EnumerationItem other) {
return evalID.compareTo(other.getEvaluator().getComponentId());
}
}
@Override
public boolean canSetOrientation() {
return model.getTableType() != TableType.ZERO_DIMENSIONAL;
}
@Override
public boolean canTranspose() {
return model.getTableType() == TableType.TWO_DIMENSIONAL;
}
@Override
public AbbreviationSettings getRowLabelAbbreviationSettings() {
if (!isSingleCellSelection()) {
return null;
} else {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
String fullLabel = tableModel.getFullRowName(table.getSelectedRows()[0]);
LabelAbbreviations currentAbbrevs = tableModel.getRowLabelAbbreviations(table.getSelectedRows()[0]);
Abbreviations availableAbbrevs = ServiceAccess.getService(AbbreviationService.class).getAbbreviations(fullLabel);
return new AbbreviationSettings(fullLabel, availableAbbrevs, currentAbbrevs);
}
}
@Override
public void setRowLabelAbbreviations(AbbreviationSettings settings) {
if (isSingleCellSelection()) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
tableModel.setRowLabelAbbreviations(table.getSelectedRows()[0], settings.getAbbreviations());
manifestation.saveCellSettings();
}
}
@Override
public AbbreviationSettings getColumnLabelAbbreviationSettings() {
if (!isSingleCellSelection()) {
return null;
} else {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
String fullLabel = tableModel.getFullColumnName(table.getSelectedColumns()[0]);
LabelAbbreviations currentAbbrevs = tableModel.getColumnLabelAbbreviations(table.getSelectedColumns()[0]);
Abbreviations availableAbbrevs = ServiceAccess.getService(AbbreviationService.class).getAbbreviations(fullLabel);
return new AbbreviationSettings(fullLabel, availableAbbrevs, currentAbbrevs);
}
}
@Override
public void setColumnLabelAbbreviations(AbbreviationSettings settings) {
if (isSingleCellSelection()) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
tableModel.setColumnLabelAbbreviations(table.getSelectedColumns()[0], settings.getAbbreviations());
table.updateColumnsHeaderValuesOnly();
manifestation.saveCellSettings();
}
}
@Override
public AbbreviationSettings getCellLabelAbbreviationSettings() {
if (!isSingleCellSelection()) {
return null;
} else {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
String fullLabel = tableModel.getFullCellName(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
LabelAbbreviations currentAbbrevs = tableModel.getCellLabelAbbreviations(tableModel.getKey(component));
Abbreviations availableAbbrevs = ServiceAccess.getService(AbbreviationService.class).getAbbreviations(fullLabel);
return new AbbreviationSettings(fullLabel, availableAbbrevs, currentAbbrevs);
}
}
@Override
public void setCellLabelAbbreviations(AbbreviationSettings settings) {
if (isSingleCellSelection()) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(table.getSelectedRows()[0], table.getSelectedColumns()[0]);
tableModel.setCellLabelAbbreviations(tableModel.getKey(component), settings.getAbbreviations());
manifestation.saveCellSettings();
}
}
@Override
public ContentAlignment getRowHeaderAlignment() {
ContentAlignment alignment = null;
for (Integer row : table.getSelectedRows()) {
ContentAlignment rowAlignment = table.getRowHeaderAlignment(row);
if (alignment!=null && alignment!=rowAlignment) {
return null;
}
alignment = rowAlignment;
}
return alignment;
}
@Override
public void setRowHeaderAlignment(ContentAlignment newAlignment) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderAlignment(row, newAlignment);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public BorderState getRowHeaderBorderState() {
BorderState commonBorderState = null;
for (Integer row : table.getSelectedRows()) {
BorderState rowBorderState = table.getRowHeaderBorderState(row);
if (commonBorderState!=null && commonBorderState!=rowBorderState) {
return null;
}
commonBorderState = rowBorderState;
}
return commonBorderState;
}
@Override
public void setRowHeaderBorderState(BorderState newBorderState) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderBorderState(row, newBorderState);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setRowHeaderFontName(ComboBoxModel comboBoxModel) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderFontName(row,
TableFormattingConstants.JVMFontFamily.class.cast(
comboBoxModel.getSelectedItem()));
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setRowHeaderFontStyle(int newStyle) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderFontStyle(row, Integer.valueOf(newStyle));
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setRowHeaderTextAttribute(int newTextAttribute) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderTextAttribute(row, Integer.valueOf(newTextAttribute));
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setColumnHeaderTextAttribute(int newTextAttribute) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderTextAttribute(col, Integer.valueOf(newTextAttribute));
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public void setColumnHeaderFontName(ComboBoxModel comboBoxModel) {
for (Integer column : table.getSelectedColumns()) {
table.setColumnHeaderFontName(column, JVMFontFamily.class.cast(comboBoxModel.getSelectedItem()));
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public void setColumnHeaderFontStyle(int fontStyle) {
for (Integer column : table.getSelectedColumns()) {
table.setColumnHeaderFontStyle(column, Integer.valueOf(fontStyle));
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public ContentAlignment getColumnHeaderAlignment() {
ContentAlignment alignment = null;
for (Integer col : table.getSelectedColumns()) {
ContentAlignment columnAlignment = table.getColumnHeaderAlignment(col);
if (alignment!=null && alignment!=columnAlignment) {
return null;
}
alignment = columnAlignment;
}
return alignment;
}
@Override
public void setColumnHeaderAlignment(ContentAlignment newAlignment) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderAlignment(col, newAlignment);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public BorderState getColumnHeaderBorderState() {
BorderState commonBorderState = null;
for (Integer col : table.getSelectedColumns()) {
BorderState colBorderState = table.getColumnHeaderBorderState(col);
if (commonBorderState!=null && commonBorderState!=colBorderState) {
return null;
}
commonBorderState = colBorderState;
}
return commonBorderState;
}
@Override
public void setColumnHeaderBorderState(BorderState newBorderState) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderBorderState(col, newBorderState);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public ContentAlignment getCellAlignment() {
if (isSelectionContainsEmptyCells()) {
return null;
}
ContentAlignment alignment = null;
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
TableCellSettings settings = tableModel.getCellSettings(tableModel.getKey(component));
ContentAlignment cellAlignment = settings.getAlignment();
if (alignment!=null && cellAlignment!=alignment) {
return null;
}
alignment = cellAlignment;
}
}
return alignment;
}
@Override
public void setCellAlignment(ContentAlignment newAlignment) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
TableCellSettings settings = tableModel.getCellSettings(tableModel.getKey(component));
settings.setAlignment(newAlignment);
}
}
manifestation.saveCellSettings();
}
@Override
public int getTableRowCount() {
return table.getTable().getRowCount();
}
@Override
public int getTableColumnCount() {
return table.getTable().getColumnCount();
}
@Override
public BorderState getBorderState() {
if (isSelectionContainsEmptyCells()) {
return new BorderState(BorderEdge.NONE.value());
}
BorderState fourEdgeControlState = new BorderState(BorderEdge.NONE.value());
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
fourEdgeControlState = settings.getCellBorderState();
assert fourEdgeControlState != null;
}
}
return fourEdgeControlState;
}
@Override
public void mergeCellFontStyle(ButtonModel boldModel, ButtonModel italicModel) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
if (boldModel.isSelected()) {
if (italicModel.isSelected()) {
settings.setFontStyle(Font.BOLD+Font.ITALIC);
} else {
settings.setFontStyle(Font.BOLD);
}
} else {
if (italicModel.isSelected()) {
settings.setFontStyle(Font.ITALIC);
} else {
settings.setFontStyle(Font.PLAIN);
}
}
manifestation.saveCellSettings();
}
}
}
@Override
public void mergeBorderState(BorderState controllerState) {
ComponentTableModel tableModel = ComponentTableModel.class.cast(model);
for (Integer row : table.getSelectedRows()) {
for (Integer col : table.getSelectedColumns()) {
BorderState stateToUpdate = null;
AbstractComponent component = (AbstractComponent) model.getStoredValueAt(row, col);
if (component == null) continue; // component-less cells
String id = tableModel.getKey(component);
TableCellSettings settings = tableModel.getCellSettings(id);
stateToUpdate = settings.getCellBorderState();
// for each selected cell, either clear it or set it according to the controller edge state and multiple selection criteria.
if (!controllerState.hasWestBorder()) {
stateToUpdate.removeBorderState(BorderEdge.WEST.value());
} else {
if (controllerState.hasWestBorder() && shouldToggleWest(row, col)) {
stateToUpdate.addBorderState(BorderEdge.WEST.value());
}
}
if (!controllerState.hasNorthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.NORTH.value());
} else {
if (controllerState.hasNorthBorder() && shouldToggleNorth(row, col)) {
stateToUpdate.addBorderState(BorderEdge.NORTH.value());
}
}
if (!controllerState.hasEastBorder()) {
stateToUpdate.removeBorderState(BorderEdge.EAST.value());
} else {
if (controllerState.hasEastBorder() && shouldToggleEast(row, col)) {
stateToUpdate.addBorderState(BorderEdge.EAST.value());
}
}
if (!controllerState.hasSouthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.SOUTH.value());
} else {
if (controllerState.hasSouthBorder() && shouldToggleSouth(row, col)) {
stateToUpdate.addBorderState(BorderEdge.SOUTH.value());
}
}
settings.setCellBorderState(stateToUpdate);
}
}
manifestation.saveCellSettings();
}
@Override
public void mergeRowHeaderBorderState(BorderState controllerState) {
for (Integer row : table.getSelectedRows()) {
BorderState stateToUpdate = table.getRowHeaderBorderState(row);
// for each selected cell, either clear it or set it according to the controller edge state and multiple selection criteria.
if (!controllerState.hasWestBorder()) {
stateToUpdate.removeBorderState(BorderEdge.WEST.value());
} else {
stateToUpdate.addBorderState(BorderEdge.WEST.value());
}
if (!controllerState.hasNorthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.NORTH.value());
} else {
stateToUpdate.addBorderState(BorderEdge.NORTH.value());
}
if (!controllerState.hasEastBorder()) {
stateToUpdate.removeBorderState(BorderEdge.EAST.value());
} else {
stateToUpdate.addBorderState(BorderEdge.EAST.value());
}
if (!controllerState.hasSouthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.SOUTH.value());
} else {
stateToUpdate.addBorderState(BorderEdge.SOUTH.value());
}
table.setRowHeaderBorderState(row,stateToUpdate);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void mergeColumnHeaderBorderState(BorderState controllerState) {
for (Integer col : table.getSelectedColumns()) {
BorderState stateToUpdate = table.getColumnHeaderBorderState(col);
// for each selected cell, either clear it or set it according to the controller edge state and multiple selection criteria.
if (!controllerState.hasWestBorder()) {
stateToUpdate.removeBorderState(BorderEdge.WEST.value());
} else {
stateToUpdate.addBorderState(BorderEdge.WEST.value());
}
if (!controllerState.hasNorthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.NORTH.value());
} else {
stateToUpdate.addBorderState(BorderEdge.NORTH.value());
}
if (!controllerState.hasEastBorder()) {
stateToUpdate.removeBorderState(BorderEdge.EAST.value());
} else {
stateToUpdate.addBorderState(BorderEdge.EAST.value());
}
if (!controllerState.hasSouthBorder()) {
stateToUpdate.removeBorderState(BorderEdge.SOUTH.value());
} else {
stateToUpdate.addBorderState(BorderEdge.SOUTH.value());
}
table.setColumnHeaderBorderState(col,stateToUpdate);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
private boolean shouldToggleEast(int row, int col) {
int [] selectedCols = table.getSelectedColumns();
int maximumSelectedColumnInThisRow = -1;
for (int r : table.getSelectedRows()) {
if (r != row) continue;
maximumSelectedColumnInThisRow = maximum(selectedCols);
}
assert maximumSelectedColumnInThisRow >= 0;
return col == maximumSelectedColumnInThisRow;
}
private boolean shouldToggleWest(int row, int col) {
int [] selectedCols = table.getSelectedColumns();
int minimumSelectedColumnInThisRow = -1;
for (int r : table.getSelectedRows()) {
if (r != row) continue;
minimumSelectedColumnInThisRow = minimum(selectedCols);
}
assert minimumSelectedColumnInThisRow >= 0;
return col == minimumSelectedColumnInThisRow;
}
private boolean shouldToggleNorth(int row, int col) {
int [] selectedRows = table.getSelectedRows();
int minimumSelectedRowInThisColumn = -1;
for (int c : table.getSelectedColumns()) {
if (c != col) continue;
minimumSelectedRowInThisColumn = minimum(selectedRows);
}
assert minimumSelectedRowInThisColumn >= 0;
return row == minimumSelectedRowInThisColumn;
}
private boolean shouldToggleSouth(int row, int col) {
int [] selectedRows = table.getSelectedRows();
int maximumSelectedRowInThisColumn = -1;
for (int c : table.getSelectedColumns()) {
if (c != col) continue;
maximumSelectedRowInThisColumn = maximum(selectedRows);
}
assert maximumSelectedRowInThisColumn >= 0;
return row == maximumSelectedRowInThisColumn;
}
/** Minimum
* @param array
* @return the min in this array
*/
private int minimum(int[] selectedItem) {
assert selectedItem.length >= 1;
int min = selectedItem[0];
for (int i=1; i < selectedItem.length; i++) {
if (selectedItem[i] < min) {
min = selectedItem[i];
}
}
return min;
}
/** Maximum.
* @param array
* @return the max in this array
*/
private int maximum(int[] selectedItem) {
assert selectedItem.length >= 1;
int max = selectedItem[0];
for (int i=1; i< selectedItem.length; i++) {
if (selectedItem[i] > max) {
max = selectedItem[i];
}
}
return max;
}
@Override
public void setRowHeaderFontSize(int fontSize) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderFontSize(row, fontSize);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setColumnHeaderFontSize(int fontSize) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderFontSize(col, fontSize);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public void setRowHeaderFontColor(Color fontColor) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderFontColor(row, fontColor);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setRowHeaderBorderColor(Color borderColor) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderBorderColor(row, borderColor);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setColumnHeaderFontColor(Color fontColor) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderFontColor(col, fontColor);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public void setColumnHeaderBorderColor(Color borderColor) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderBorderColor(col, borderColor);
}
manifestation.saveCellSettings();
table.getTable().getTableHeader().repaint();
}
@Override
public void setRowHeaderBackgroundColor(Color fontColor) {
for (Integer row : table.getSelectedRows()) {
table.setRowHeaderBackgroundColor(row, fontColor);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public void setColumnHeaderBackgroundColor(Color fontColor) {
for (Integer col : table.getSelectedColumns()) {
table.setColumnHeaderBackgroundColor(col, fontColor);
}
manifestation.saveCellSettings();
table.getRowHeaders().repaint();
}
@Override
public Integer getRowFontStyle() {
Integer commonStyle = null;
for (Integer row : table.getSelectedRows()) {
Integer aStyle = table.getRowHeaderFontStyle(row);
if (commonStyle!=null && commonStyle!=aStyle) {
return null;
}
commonStyle = aStyle;
}
return commonStyle;
}
@Override
public Integer getRowHeaderTextAttribute() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderTextAttribute(table.getSelectedRows()[0]);
}
Integer commonTextAttribute = null;
for (Integer row : table.getSelectedRows()) {
Integer aTextAttribute = table.getRowHeaderTextAttribute(row);
if (commonTextAttribute!=null && commonTextAttribute!=aTextAttribute) {
return null;
}
commonTextAttribute = aTextAttribute;
}
return commonTextAttribute;
}
@Override
public Integer getColumnHeaderTextAttribute() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderTextAttribute(table.getSelectedColumns()[0]);
}
Integer commonTextAttribute = null;
for (Integer col : table.getSelectedColumns()) {
Integer aTextAttribute = table.getColumnHeaderTextAttribute(col);
if (commonTextAttribute!=null && commonTextAttribute!=aTextAttribute) {
return null;
}
commonTextAttribute = aTextAttribute;
}
return commonTextAttribute;
}
@Override
public JVMFontFamily getRowHeaderFontName() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderFontName(table.getSelectedRows()[0]);
}
JVMFontFamily commonFont = null;
for (Integer row : table.getSelectedRows()) {
JVMFontFamily aFont = table.getRowHeaderFontName(row);
if (commonFont !=null && !commonFont.equals(aFont)) {
return null;
}
commonFont = aFont;
}
return commonFont;
}
@Override
public Integer getColumnHeaderFontStyle() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderFontStyle(table.getSelectedColumns()[0]);
}
Integer commonStyle = null;
for (Integer col : table.getSelectedColumns()) {
Integer aStyle = table.getColumnHeaderFontStyle(col);
if (commonStyle!=null && commonStyle!=aStyle) {
return null;
}
commonStyle = aStyle;
}
return commonStyle;
}
@Override
public Integer getRowHeaderFontSize() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderFontSize(table.getSelectedRows()[0]);
}
Integer commonSize = null;
for (Integer row : table.getSelectedRows()) {
Integer aSize = table.getRowHeaderFontSize(row);
if (commonSize!=null && commonSize!=aSize) {
return null;
}
commonSize = aSize;
}
return commonSize;
}
@Override
public Integer getColumnHeaderFontSize() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderFontSize(table.getSelectedColumns()[0]);
}
Integer commonSize = null;
for (Integer col : table.getSelectedColumns()) {
Integer aSize = table.getColumnHeaderFontSize(col);
if (commonSize!=null && commonSize!=aSize) {
return null;
}
commonSize = aSize;
}
return commonSize;
}
@Override
public Color getRowHeaderFontColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderFontColor(table.getSelectedRows()[0]);
}
Color commonColor = null;
for (Integer row : table.getSelectedRows()) {
Color aColor = table.getRowHeaderFontColor(row);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public Color getRowHeaderBorderColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderBorderColor(table.getSelectedRows()[0]);
}
Color commonColor = null;
for (Integer row : table.getSelectedRows()) {
Color aColor = table.getRowHeaderBorderColor(row);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public Color getColumnHeaderFontColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderFontColor(table.getSelectedColumns()[0]);
}
Color commonColor = null;
for (Integer col : table.getSelectedColumns()) {
Color aColor = table.getColumnHeaderFontColor(col);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public Color getColumnHeaderBorderColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderBorderColor(table.getSelectedColumns()[0]);
}
Color commonColor = null;
for (Integer col : table.getSelectedColumns()) {
Color aColor = table.getColumnHeaderBorderColor(col);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public Color getRowHeaderBackgroundColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getRowHeaderBackgroundColor(table.getSelectedRows()[0]);
}
Color commonColor = null;
for (Integer row : table.getSelectedRows()) {
Color aColor = table.getRowHeaderBackgroundColor(row);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public Color getColumnHeaderBackgroundColor() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderBackgroundColor(table.getSelectedColumns()[0]);
}
Color commonColor = null;
for (Integer col : table.getSelectedColumns()) {
Color aColor = table.getColumnHeaderBackgroundColor(col);
if (commonColor!=null && commonColor!=aColor) {
return null;
}
commonColor = aColor;
}
return commonColor;
}
@Override
public JVMFontFamily getColumnHeaderFontName() {
if (isSelectionContainsEmptyCells()) {
return null;
}
if (isSingleCellSelection()) {
return table.getColumnHeaderFontName(table.getSelectedColumns()[0]);
}
JVMFontFamily commonFont = null;
for (Integer col : table.getSelectedColumns()) {
JVMFontFamily aFont = table.getColumnHeaderFontName(col);
if (commonFont !=null && !commonFont.equals(aFont)) {
return null;
}
commonFont = aFont;
}
return commonFont;
}
}