/*
* $Id$
*
* Copyright 2009 Sun Microsystems, Inc., 4150 Network Circle,
* Santa Clara, California 95054, U.S.A. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
package org.jdesktop.swingx.sort;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import org.jdesktop.swingx.renderer.StringValue;
import org.jdesktop.swingx.renderer.StringValues;
/**
* A writable implemenation of StringValueProvider. Typically, this is created and
* maintained by a collection view and then passed over to interested parties. It is
* modeled/implemented after the default renderer maintenance in a JTable.<p>
*
* PENDING JW: for safety - better not implement but return a provider. We probably don't want
* readers to frickle around here?.
*
* @author Jeanette Winzenburg
*/
public final class StringValueRegistry implements StringValueProvider {
@SuppressWarnings("unused")
private static final Logger LOG = Logger
.getLogger(StringValueRegistry.class.getName());
private Map<Class<?>, StringValue> perClass;
private HashMap<Integer, StringValue> perColumn;
private HashMap<Integer, Class<?>> classPerColumn;
/**
* {@inheritDoc} <p>
*/
@Override
public StringValue getStringValue(int row, int column) {
StringValue sv = getPerColumnMap().get(column);
if (sv == null) {
sv = getStringValueByClass(getClass(row, column));
}
if (sv == null) {
sv = getStringValueByClass(Object.class);
}
return sv != null ? sv : StringValues.TO_STRING;
}
//-------------------- manage
/**
* Sets a StringValue to use for the given column. If the converter is null,
* the mapping is removed.
*
* @param sv the StringValue to use for the given column.
* @param column the column index in model coordinates.
*
*/
public void setStringValue(StringValue sv, int column) {
// PENDING really remove mapping if sv null
getPerColumnMap().put(column, sv);
}
/**
* Removes all per-column mappings of StringValues.
*
*/
public void clearColumnStringValues() {
getPerColumnMap().clear();
}
/**
* Sets the StringValue to use for the given class. If the converter is null,
* the mapping is removed.
*
* @param sv the StringValue to use for the given column.
* @param clazz the class
*/
public void setStringValue(StringValue sv, Class<?> clazz) {
// PENDING really remove mapping if sv null
getPerClassMap().put(clazz, sv);
}
/**
* Returns the StringValue registered for the given class. <p>
*
* <b>This is temporarily exposed for testing only - do not use, it will
* be removed very soon!</b>
*
* @param clazz the class to find the registered StringValue for
* @return the StringValue registered for the class, or null if not directly
* registered.
*/
public StringValue getStringValue(Class<?> clazz) {
return getPerClassMap().get(clazz);
}
/**
* Sets the column class.
*
* @param clazz
* @param column index in model coordinates
*/
public void setColumnClass(Class<?> clazz, int column) {
getColumnClassMap().put(column, clazz);
}
/**
* @param classPerColumn
*/
public void setColumnClasses(Map<Integer, Class<?>> classPerColumn) {
this.classPerColumn = classPerColumn != null ?
new HashMap<Integer, Class<?>>(classPerColumn) : null;
}
/**
*
* @param clazz
* @return
*/
private StringValue getStringValueByClass(Class<?> clazz) {
if (clazz == null) return null;
StringValue sv = getPerClassMap().get(clazz);
if (sv != null) return sv;
return getStringValueByClass(clazz.getSuperclass());
}
/**
* Returns the Class of the column.
*
* @param row
* @param column
* @return
*/
private Class<?> getClass(int row, int column) {
Class<?> clazz = getColumnClassMap().get(column);
return clazz != null ? clazz : Object.class;
}
/**
* Returns the Map which stores the per-column Class, lazily
* creates one if null.
*
* @return the per-column storage map of Class
*/
private Map<Integer, Class<?>> getColumnClassMap() {
if (classPerColumn == null) {
classPerColumn = new HashMap<Integer, Class<?>>();
}
return classPerColumn;
}
/**
* Returns the Map which stores the per-class StringValues, lazily
* creates one if null.
*
* @return the per-class storage map of StringValues
*/
private Map<Class<?>, StringValue> getPerClassMap() {
if (perClass == null) {
perClass = new HashMap<Class<?>, StringValue>();
}
return perClass;
}
/**
* Returns the Map which stores the per-column StringValues, lazily
* creates one if null.
*
* @return the per-column storage map of StringValues
*/
private Map<Integer, StringValue> getPerColumnMap() {
if (perColumn == null) {
perColumn = new HashMap<Integer, StringValue>();
}
return perColumn;
}
}