bundles/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/viewers/TreeViewerUpdatableTreeExtended.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  ******************************************************************************/
 package org.eclipse.jface.internal.databinding.viewers;

 import java.util.HashMap;

 import org.eclipse.jface.databinding.BindingException;
 import org.eclipse.jface.databinding.ChangeEvent;
 import org.eclipse.jface.databinding.IChangeListener;
 import org.eclipse.jface.databinding.IDataBindingContext;
 import org.eclipse.jface.databinding.converter.IConverter;
 import org.eclipse.jface.databinding.converters.IdentityConverter;
 import org.eclipse.jface.databinding.validator.IValidator;
 import org.eclipse.jface.databinding.viewers.TreeViewerDescription;
 import org.eclipse.jface.databinding.viewers.TableViewerDescription.Column;
 import org.eclipse.jface.internal.databinding.beans.PropertyHelper;
 import org.eclipse.jface.viewers.CellEditor;
 import org.eclipse.jface.viewers.ICellModifier;
 import org.eclipse.jface.viewers.ITableLabelProvider;
 import org.eclipse.jface.viewers.LabelProvider;
 import org.eclipse.jface.viewers.TextCellEditor;
 import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.jface.viewers.ViewerLabel;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Item;

 /**
  * @since 3.2
  *
  */
 public class TreeViewerUpdatableTreeExtended extends TreeViewerUpdatableTree {

 	class ColumnInfo{ // boolean default value is false
 		boolean converterDefaulted;
 		boolean validatorDefaulted;
 		boolean cellEditorDefaulted;
 	}

 	class TreeLabelProvider extends LabelProvider implements ITableLabelProvider {
 		private Object getValue(Object element, Column column) {
 			Object value = treeViewerDescription.getCellModifier().getValue(
 					element, Integer.toString(treeViewerDescription.getColumnIndex(element.getClass(), column)));
 			return value;
 		}

 		private Object getConvertedValue(Object element, Column column) {
 			String propertyName = column.getPropertyName();
 			Object value;
 			if (propertyName == null)
 				value = element;
 			else
 				value = getValue(element, column);

 			Object convertedValue = column.getConverter().convertModelToTarget(
 					value);
 			return convertedValue;
 		}

 		public Image getColumnImage(Object element, int columnIndex) {
 			if (columnIndex<treeViewerDescription.getColumnCount(element.getClass()) && columnIndex>=0) {
 				Column column = getColumn(element.getClass(), columnIndex);
 				IConverter converter = column.getConverter();
 				if (converter.getTargetType().equals(ViewerLabel.class)) {
 					ViewerLabel viewerLabel = (ViewerLabel) getConvertedValue(
 							element, column);
 					return viewerLabel.getImage();
 				}
 			}
 			return null;
 		}

 		public String getColumnText(Object element, int columnIndex) {
 			Object convertedValue=null;
 			if (columnIndex<treeViewerDescription.getColumnCount(element.getClass()) && columnIndex>=0) {
 			  Column column = getColumn(element.getClass(), columnIndex);
 			  convertedValue = getConvertedValue(element, column);
 			  IConverter converter = column.getConverter();
 			  if (converter.getTargetType().equals(ViewerLabel.class)) {
 					ViewerLabel viewerLabel = (ViewerLabel) convertedValue;
 					return viewerLabel.getText();
 			  }
 			}
 			return convertedValue==null? "": (String) convertedValue; //$NON-NLS-1$
 		}

 		// support the case where a TreeColumn() was not placed on the tree
 		public Image getImage(Object element) {
 			return getColumnImage(element,0);
 		}

 		public String getText(Object element) {
 			return getColumnText(element, 0);
 		}
 	}


 	private HashMap columnInfos = new HashMap();

 	private IDataBindingContext dataBindingContext;

 	private final TreeViewerDescription treeViewerDescription;

 	private final IChangeListener dummyListener = new IChangeListener() {
 		public void handleChange(ChangeEvent changeEvent) {
 		}
 	};

 	/**
 	 * @param treeViewerDescription
 	 * @param dataBindingContext
 	 */
 	public TreeViewerUpdatableTreeExtended(
 			TreeViewerDescription treeViewerDescription, IDataBindingContext dataBindingContext) {
 		super(treeViewerDescription.getTreeViewer(), treeViewerDescription.getClassTypes());
 		this.treeViewerDescription = treeViewerDescription;
 		this.dataBindingContext=dataBindingContext;

 		fillDescriptionDefaults(dataBindingContext);
 		TreeViewer tableViewer = treeViewerDescription.getTreeViewer();
 		// TODO synchronize columns on the widget side (create missing columns,
 		// set name if not already set)
 		tableViewer.setLabelProvider(new TreeLabelProvider());
 		tableViewer.setCellModifier(treeViewerDescription.getCellModifier());
 		int columnCount = getColumnCount();
 		String[] columnProperties = new String[columnCount];
 		//	TODO need to use the fix for Bug 113713
 		//  It is possible that one column may have multiple cell editors
 		CellEditor[] cellEditors = new CellEditor[columnCount];
 		for (int i = 0; i < columnCount; i++) {
 			columnProperties[i] = Integer.toString(i);
 			cellEditors[i] = createCellEditor(i);
 		}
 		tableViewer.setColumnProperties(columnProperties);
 		tableViewer.setCellEditors(cellEditors);
 	}

 	private int getColumnCount() {
 		int count=0;
 		Class[] types = treeViewerDescription.getClassTypes();
 		for (int i = 0; i < types.length; i++) {
 			int cc = treeViewerDescription.getColumnCount(types[i]);
 			if (cc>count)
 				count = cc;
 		}
 		return count;
 	}

 	protected CellEditor createCellEditor(final int columnIndex) {
 		Class[] classTypes = treeViewerDescription.getClassTypes();
 		CellEditor customEditor = null;
 		for (int i = 0; i < classTypes.length; i++) {
 			Column column = treeViewerDescription.getColumn(classTypes[i], columnIndex);
 			if (column!=null && column.getCellEditor()!=null) {
 				if (customEditor!=null) {
 					if (customEditor!=column.getCellEditor()) // Limitation, see Bug 113713
 						throw new BindingException("Different Cell Editors on Column: "+columnIndex); //$NON-NLS-1$
 				}
 				else
 					customEditor = column.getCellEditor();
 			}
 		}

 		if (customEditor==null)
 		    // Use a default
 			return new TextCellEditor(treeViewerDescription.getTreeViewer().getTree()) ;

 		for (int i = 0; i < classTypes.length; i++) {
 			Column column = treeViewerDescription.getColumn(classTypes[i], columnIndex);
 			column.setCellEditor(customEditor);
 		}
 		return customEditor;

 	}

 	protected ICellModifier createCellModifier(final IDataBindingContext dataBindingContext) {
 		return new ICellModifier() {

 			private Column findColumn(Class instanceType, String property) {
 				int index = Integer.parseInt(property);
 				return treeViewerDescription.getColumn(instanceType, index);
 			}

 			public boolean canModify(Object element, String property) {
 				if (element instanceof Item) {
 					element = ((Item) element).getData();
 				}
 				Column column = findColumn(element.getClass(), property);
 				if (column!=null && column.getPropertyName()!=null) {
 					return new PropertyHelper(column.getPropertyName(), element.getClass()).canSet(element);
 				}
 				return false;
 			}


 			public Object getValue(Object element, String property) {
 				if (element instanceof Item) {
 					element = ((Item) element).getData();
 				}
 				Column column = findColumn(element.getClass(), property);
 				if (column == null) {
 					return null;
 				}
 				try {
 					Object value = new PropertyHelper(column.getPropertyName(), element.getClass()).get(element);
 					return column.getConverter().convertModelToTarget(value);
 				} catch (SecurityException e) {
 					// TODO log
 				} catch (IllegalArgumentException e) {
 					// TODO log
 				}
 				return null;
 			}

 			public void modify(Object element, String property, Object value) {
 				if (element instanceof Item) {
 					element = ((Item) element).getData();
 				}
 				Column column = findColumn(element.getClass(), property);
 				if (column == null) {
 					return;
 				}
 				value = column.getConverter().convertTargetToModel(value);
 				IValidator columnValidator = column.getValidator();
 				if(columnValidator != null){
 					String errorMessage = columnValidator.isValid(value);
 					if(errorMessage != null){
 						dataBindingContext.updateValidationError(dummyListener, errorMessage);
 						return;
 					}
 				}
 				new PropertyHelper(column.getPropertyName(), element.getClass()).set(element, value);
 				viewer.update(element, new String[] { property } );
 			}
 		};
 	}

 	private void initializeColumnConverter(Column column, Class propertyType){
 		   column.setConverter(dataBindingContext.createConverter(String.class, propertyType, treeViewerDescription));
 	}

 	private void initializeColumnValidator(Column column, Class propertyType){
 		column.setValidator(new IValidator() {
 			public String isPartiallyValid(Object value) {
 				return null;
 			}

 			public String isValid(Object value) {
 				return null;
 			}
 		});
 	}

 	protected CellEditor createCellEditor(final Column column) {
 		return new TextCellEditor(treeViewerDescription.getTreeViewer().getTree()) {
 			protected void doSetValue(Object value) {
 				super.doSetValue( column.getConverter().convertModelToTarget(value));
 			}
 			protected Object doGetValue() {
 				String textValue = (String)super.doGetValue();
 				return column.getConverter().convertTargetToModel(textValue);
 			}
 		};

 	}

 	private void fillDescriptionDefaults(final IDataBindingContext dataBindingContext) {
 		Class[] types = treeViewerDescription.getClassTypes();
 		if (types==null) return;

 		for (int i=0; i<types.length; i++) {
 			int colCount = treeViewerDescription.getColumnCount(types[i]);
 			for (int j = 0; j < colCount; j++) {
 				Column column = treeViewerDescription.getColumn(types[i], j);
 				ColumnInfo info = new ColumnInfo();
 				columnInfos.put(column, info);
 				if (column.getConverter() == null) {
 					info.converterDefaulted = true;
 					if (column.getPropertyType()!=null)
 						initializeColumnConverter(column,column.getPropertyType());
 					else
 					   column.setConverter(new IdentityConverter(String.class));
 				}
 				if (column.getValidator() == null) {
 					info.validatorDefaulted = true;
 					initializeColumnValidator(column, column.getPropertyType());
 				}
 // TODO need to use this when Bug 113713 is fixed
 //				if (column.getCellEditor() == null) {
 //					info.cellEditorDefaulted = true;
 //					column.setCellEditor(createCellEditor(column));
 //				}

 			}
 		}
 		if (treeViewerDescription.getCellModifier() == null) {
 			treeViewerDescription.setCellModifier(createCellModifier(dataBindingContext));
 		}
 		if (columnInfos.isEmpty())
 			columnInfos=null;
 	}


 	protected Column getColumn(Class instanceType, int columnIndex) {
 		return treeViewerDescription.getColumn(instanceType, columnIndex);
 	}

 	protected int addElement(final Object parentElement, int index, final Object value, boolean fire) {
 		// Verify defaults, the first time data cames through
 		if(columnInfos != null && value!=null){
 			for (int i = 0; i < treeViewerDescription.getColumnCount(value.getClass()); i++) {
 				Column column = treeViewerDescription.getColumn(value.getClass(), i);
 				ColumnInfo columnInfo = (ColumnInfo) columnInfos.remove(column);
 				if (columnInfo!=null && column.getPropertyName()!=null) {
 					if(column.getPropertyType() == null && (columnInfo.cellEditorDefaulted || columnInfo.converterDefaulted || columnInfo.validatorDefaulted)){
 						// Work out the type of the column from the property name from the element type itself
 						PropertyHelper helper = new PropertyHelper(column.getPropertyName(), value.getClass());
 						Class columnType =helper.getGetter().getReturnType();
 						if(columnType != null){
 							// We have a more explicit property type that was supplied
 							if(columnInfo.converterDefaulted){
 								initializeColumnConverter(column,columnType);
 							}
 							if(columnInfo.validatorDefaulted){
 								initializeColumnValidator(column,columnType);
 							}
 						}
 					}
 				}
 			}
 			if (columnInfos.isEmpty())
 				columnInfos = null;	// No More checking
 		}
 		return super.addElement(parentElement, index, value, fire);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	******************************************************************************/
	package org.eclipse.jface.internal.databinding.viewers;

	import java.util.HashMap;

	import org.eclipse.jface.databinding.BindingException;
	import org.eclipse.jface.databinding.ChangeEvent;
	import org.eclipse.jface.databinding.IChangeListener;
	import org.eclipse.jface.databinding.IDataBindingContext;
	import org.eclipse.jface.databinding.converter.IConverter;
	import org.eclipse.jface.databinding.converters.IdentityConverter;
	import org.eclipse.jface.databinding.validator.IValidator;
	import org.eclipse.jface.databinding.viewers.TreeViewerDescription;
	import org.eclipse.jface.databinding.viewers.TableViewerDescription.Column;
	import org.eclipse.jface.internal.databinding.beans.PropertyHelper;
	import org.eclipse.jface.viewers.CellEditor;
	import org.eclipse.jface.viewers.ICellModifier;
	import org.eclipse.jface.viewers.ITableLabelProvider;
	import org.eclipse.jface.viewers.LabelProvider;
	import org.eclipse.jface.viewers.TextCellEditor;
	import org.eclipse.jface.viewers.TreeViewer;
	import org.eclipse.jface.viewers.ViewerLabel;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.widgets.Item;

	/**
	* @since 3.2
	*
	*/
	public class TreeViewerUpdatableTreeExtended extends TreeViewerUpdatableTree {

	class ColumnInfo{ // boolean default value is false
	boolean converterDefaulted;
	boolean validatorDefaulted;
	boolean cellEditorDefaulted;
	}

	class TreeLabelProvider extends LabelProvider implements ITableLabelProvider {
	private Object getValue(Object element, Column column) {
	Object value = treeViewerDescription.getCellModifier().getValue(
	element, Integer.toString(treeViewerDescription.getColumnIndex(element.getClass(), column)));
	return value;
	}

	private Object getConvertedValue(Object element, Column column) {
	String propertyName = column.getPropertyName();
	Object value;
	if (propertyName == null)
	value = element;
	else
	value = getValue(element, column);

	Object convertedValue = column.getConverter().convertModelToTarget(
	value);
	return convertedValue;
	}

	public Image getColumnImage(Object element, int columnIndex) {
	if (columnIndex<treeViewerDescription.getColumnCount(element.getClass()) && columnIndex>=0) {
	Column column = getColumn(element.getClass(), columnIndex);
	IConverter converter = column.getConverter();
	if (converter.getTargetType().equals(ViewerLabel.class)) {
	ViewerLabel viewerLabel = (ViewerLabel) getConvertedValue(
	element, column);
	return viewerLabel.getImage();
	}
	}
	return null;
	}

	public String getColumnText(Object element, int columnIndex) {
	Object convertedValue=null;
	if (columnIndex<treeViewerDescription.getColumnCount(element.getClass()) && columnIndex>=0) {
	Column column = getColumn(element.getClass(), columnIndex);
	convertedValue = getConvertedValue(element, column);
	IConverter converter = column.getConverter();
	if (converter.getTargetType().equals(ViewerLabel.class)) {
	ViewerLabel viewerLabel = (ViewerLabel) convertedValue;
	return viewerLabel.getText();
	}
	}
	return convertedValue==null? "": (String) convertedValue; //$NON-NLS-1$
	}

	// support the case where a TreeColumn() was not placed on the tree
	public Image getImage(Object element) {
	return getColumnImage(element,0);
	}

	public String getText(Object element) {
	return getColumnText(element, 0);
	}
	}



	private HashMap columnInfos = new HashMap();

	private IDataBindingContext dataBindingContext;

	private final TreeViewerDescription treeViewerDescription;

	private final IChangeListener dummyListener = new IChangeListener() {
	public void handleChange(ChangeEvent changeEvent) {
	}
	};

	/**
	* @param treeViewerDescription
	* @param dataBindingContext
	*/
	public TreeViewerUpdatableTreeExtended(
	TreeViewerDescription treeViewerDescription, IDataBindingContext dataBindingContext) {
	super(treeViewerDescription.getTreeViewer(), treeViewerDescription.getClassTypes());
	this.treeViewerDescription = treeViewerDescription;
	this.dataBindingContext=dataBindingContext;

	fillDescriptionDefaults(dataBindingContext);
	TreeViewer tableViewer = treeViewerDescription.getTreeViewer();
	// TODO synchronize columns on the widget side (create missing columns,
	// set name if not already set)
	tableViewer.setLabelProvider(new TreeLabelProvider());
	tableViewer.setCellModifier(treeViewerDescription.getCellModifier());
	int columnCount = getColumnCount();
	String[] columnProperties = new String[columnCount];
	// TODO need to use the fix for Bug 113713
	// It is possible that one column may have multiple cell editors
	CellEditor[] cellEditors = new CellEditor[columnCount];
	for (int i = 0; i < columnCount; i++) {
	columnProperties[i] = Integer.toString(i);
	cellEditors[i] = createCellEditor(i);
	}
	tableViewer.setColumnProperties(columnProperties);
	tableViewer.setCellEditors(cellEditors);
	}

	private int getColumnCount() {
	int count=0;
	Class[] types = treeViewerDescription.getClassTypes();
	for (int i = 0; i < types.length; i++) {
	int cc = treeViewerDescription.getColumnCount(types[i]);
	if (cc>count)
	count = cc;
	}
	return count;
	}

	protected CellEditor createCellEditor(final int columnIndex) {
	Class[] classTypes = treeViewerDescription.getClassTypes();
	CellEditor customEditor = null;
	for (int i = 0; i < classTypes.length; i++) {
	Column column = treeViewerDescription.getColumn(classTypes[i], columnIndex);
	if (column!=null && column.getCellEditor()!=null) {
	if (customEditor!=null) {
	if (customEditor!=column.getCellEditor()) // Limitation, see Bug 113713
	throw new BindingException("Different Cell Editors on Column: "+columnIndex); //$NON-NLS-1$
	}
	else
	customEditor = column.getCellEditor();
	}
	}

	if (customEditor==null)
	// Use a default
	return new TextCellEditor(treeViewerDescription.getTreeViewer().getTree()) ;

	for (int i = 0; i < classTypes.length; i++) {
	Column column = treeViewerDescription.getColumn(classTypes[i], columnIndex);
	column.setCellEditor(customEditor);
	}
	return customEditor;

	}

	protected ICellModifier createCellModifier(final IDataBindingContext dataBindingContext) {
	return new ICellModifier() {

	private Column findColumn(Class instanceType, String property) {
	int index = Integer.parseInt(property);
	return treeViewerDescription.getColumn(instanceType, index);
	}

	public boolean canModify(Object element, String property) {
	if (element instanceof Item) {
	element = ((Item) element).getData();
	}
	Column column = findColumn(element.getClass(), property);
	if (column!=null && column.getPropertyName()!=null) {
	return new PropertyHelper(column.getPropertyName(), element.getClass()).canSet(element);
	}
	return false;
	}


	public Object getValue(Object element, String property) {
	if (element instanceof Item) {
	element = ((Item) element).getData();
	}
	Column column = findColumn(element.getClass(), property);
	if (column == null) {
	return null;
	}
	try {
	Object value = new PropertyHelper(column.getPropertyName(), element.getClass()).get(element);
	return column.getConverter().convertModelToTarget(value);
	} catch (SecurityException e) {
	// TODO log
	} catch (IllegalArgumentException e) {
	// TODO log
	}
	return null;
	}

	public void modify(Object element, String property, Object value) {
	if (element instanceof Item) {
	element = ((Item) element).getData();
	}
	Column column = findColumn(element.getClass(), property);
	if (column == null) {
	return;
	}
	value = column.getConverter().convertTargetToModel(value);
	IValidator columnValidator = column.getValidator();
	if(columnValidator != null){
	String errorMessage = columnValidator.isValid(value);
	if(errorMessage != null){
	dataBindingContext.updateValidationError(dummyListener, errorMessage);
	return;
	}
	}
	new PropertyHelper(column.getPropertyName(), element.getClass()).set(element, value);
	viewer.update(element, new String[] { property } );
	}
	};
	}

	private void initializeColumnConverter(Column column, Class propertyType){
	column.setConverter(dataBindingContext.createConverter(String.class, propertyType, treeViewerDescription));
	}

	private void initializeColumnValidator(Column column, Class propertyType){
	column.setValidator(new IValidator() {
	public String isPartiallyValid(Object value) {
	return null;
	}

	public String isValid(Object value) {
	return null;
	}
	});
	}

	protected CellEditor createCellEditor(final Column column) {
	return new TextCellEditor(treeViewerDescription.getTreeViewer().getTree()) {
	protected void doSetValue(Object value) {
	super.doSetValue( column.getConverter().convertModelToTarget(value));
	}
	protected Object doGetValue() {
	String textValue = (String)super.doGetValue();
	return column.getConverter().convertTargetToModel(textValue);
	}
	};

	}

	private void fillDescriptionDefaults(final IDataBindingContext dataBindingContext) {
	Class[] types = treeViewerDescription.getClassTypes();
	if (types==null) return;

	for (int i=0; i<types.length; i++) {
	int colCount = treeViewerDescription.getColumnCount(types[i]);
	for (int j = 0; j < colCount; j++) {
	Column column = treeViewerDescription.getColumn(types[i], j);
	ColumnInfo info = new ColumnInfo();
	columnInfos.put(column, info);
	if (column.getConverter() == null) {
	info.converterDefaulted = true;
	if (column.getPropertyType()!=null)
	initializeColumnConverter(column,column.getPropertyType());
	else
	column.setConverter(new IdentityConverter(String.class));
	}
	if (column.getValidator() == null) {
	info.validatorDefaulted = true;
	initializeColumnValidator(column, column.getPropertyType());
	}
	// TODO need to use this when Bug 113713 is fixed
	// if (column.getCellEditor() == null) {
	// info.cellEditorDefaulted = true;
	// column.setCellEditor(createCellEditor(column));
	// }

	}
	}
	if (treeViewerDescription.getCellModifier() == null) {
	treeViewerDescription.setCellModifier(createCellModifier(dataBindingContext));
	}
	if (columnInfos.isEmpty())
	columnInfos=null;
	}



	protected Column getColumn(Class instanceType, int columnIndex) {
	return treeViewerDescription.getColumn(instanceType, columnIndex);
	}

	protected int addElement(final Object parentElement, int index, final Object value, boolean fire) {
	// Verify defaults, the first time data cames through
	if(columnInfos != null && value!=null){
	for (int i = 0; i < treeViewerDescription.getColumnCount(value.getClass()); i++) {
	Column column = treeViewerDescription.getColumn(value.getClass(), i);
	ColumnInfo columnInfo = (ColumnInfo) columnInfos.remove(column);
	if (columnInfo!=null && column.getPropertyName()!=null) {
	if(column.getPropertyType() == null && (columnInfo.cellEditorDefaulted \|\| columnInfo.converterDefaulted \|\| columnInfo.validatorDefaulted)){
	// Work out the type of the column from the property name from the element type itself
	PropertyHelper helper = new PropertyHelper(column.getPropertyName(), value.getClass());
	Class columnType =helper.getGetter().getReturnType();
	if(columnType != null){
	// We have a more explicit property type that was supplied
	if(columnInfo.converterDefaulted){
	initializeColumnConverter(column,columnType);
	}
	if(columnInfo.validatorDefaulted){
	initializeColumnValidator(column,columnType);
	}
	}
	}
	}
	}
	if (columnInfos.isEmpty())
	columnInfos = null; // No More checking
	}
	return super.addElement(parentElement, index, value, fire);
	}
	}