/// <summary>
/// Indexer will return the corresponding renderer for the corresponding Key value.
/// </summary>
/// <param name="key"></param>
/// <value></value>
/// <remarks></remarks>
public ITreeGridCellRenderer this[string key]
{
get
{
if (key == cachedKey)
{
cachedRenderer.TreeGrid = this.treeGrid;
return(cachedRenderer);
}
cachedKey = key;
if (!this.ContainsKey(key))
{
cachedKey = key;
this.Add(cachedKey, cachedRenderer);
}
else
{
cachedRenderer = (ITreeGridCellRenderer)content[key];
}
cachedRenderer.TreeGrid = this.treeGrid;
return(cachedRenderer);
}
set
{
if (this.ContainsKey(key) && content[key] != value)
{
this.Remove(key);
}
this.Add(key, value);
}
}
/// <summary>
/// Clears the values in Renderer Dictionary.
/// </summary>
/// <remarks></remarks>
public void Clear()
{
foreach (var obj in content.Values)
{
var renderer = obj as TreeGridCellRendererBase;
if (renderer != null)
{
renderer.Dispose();
}
}
this.content.Clear();
cachedKey = "";
cachedRenderer = null;
}
/// <summary>
/// Remove the Renderer from dictionary for corresponding key vallue
/// </summary>
/// <param name="key"></param>
/// <remarks></remarks>
public void Remove(string key)
{
if (ContainsKey(key))
{
var renderer = content[key] as ITreeGridCellRenderer;
if (renderer != null)
{
renderer.Dispose();
}
this.content.Remove(key);
}
cachedKey = "";
cachedRenderer = null;
}
/// <summary>
/// Disposes all the resources used by the <see cref="Syncfusion.UI.Xaml.TreeGrid.TreeDataColumnBase"/> class.
/// </summary>
/// <param name="isDisposing">Indicates whether the call is from Dispose method or from a finalizer.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this.ColumnElement is IDisposable)
{
(this.ColumnElement as IDisposable).Dispose();
}
if (this.renderer != null)
{
this.renderer.UnloadUIElements(this);
this.renderer = null;
}
this.DataRow = null;
this.ColumnElement = null;
this.treeGridColumn = null;
}
}
/// <summary>
/// Update Renderer and UnloadUIElement if needed
/// </summary>
/// <param name="dataColumn"></param>
/// <returns></returns>
/// <remarks></remarks>
internal virtual bool UpdateRenderer(TreeDataColumnBase dataColumn, TreeGridColumn column)
{
ITreeGridCellRenderer newRenderer = null;
var update = (dataColumn.TreeGridColumn.hasCellTemplateSelector || dataColumn.TreeGridColumn.hasCellTemplate) || (column.hasCellTemplate || column.hasCellTemplateSelector);
if (this.TreeGrid.GetHeaderIndex() == dataColumn.RowIndex)
{
newRenderer = this.TreeGrid.CellRenderers["Header"];
update = dataColumn.TreeGridColumn.hasHeaderTemplate || column.hasHeaderTemplate;
}
else
{
newRenderer = column.CellType != string.Empty
? this.TreeGrid.CellRenderers[column.CellType]
: this.TreeGrid.CellRenderers["Static"];
}
if (dataColumn.Renderer == null)
{
return(false);
}
//If both are different renderer then we will unload UIElements.
//The column going to reuse and the column which uses the existing column when has CellTemplates
// Existing Column - New Column - Action
// CellTemplate - CellTemplate - Unload
// CellTemplate - None - Unload
// None - CellTemplate - Unload
// None - None - Reuse
// DataHeader will have same renderer always
if (dataColumn.Renderer != newRenderer)
{
dataColumn.Renderer.UnloadUIElements(dataColumn);
dataColumn.Renderer = newRenderer;
return(true);
}
if (update)
{
dataColumn.Renderer.UnloadUIElements(dataColumn);
return(true);
}
return(false);
}
internal bool RaiseCellValidate(RowColumnIndex currentCellIndex, ITreeGridCellRenderer renderer, bool allowattributeValidation)
{
if (IsCurrentCellValidated)
{
return(true);
}
var dataRow = treeGrid.RowGenerator.Items.FirstOrDefault(item => item.RowIndex == currentCellIndex.RowIndex);
if (dataRow == null)
{
return(false);
}
var columnBase = dataRow.VisibleColumns.FirstOrDefault(x => x.ColumnIndex == currentCellIndex.ColumnIndex);
if (columnBase == null)
{
return(false);
}
renderer = renderer ?? columnBase.Renderer;
if (renderer == null)
{
return(false);
}
//WPF-36608 - CurrenctCellvalidating event are not fired, when we select cell on treeGrid template column.
if (!columnBase.Renderer.CanValidate())
{
SetCurrentCellValidated(true);
return(true);
}
object oldValue = null;
object changedNewValue;
string errorMessage;
oldValue = this.treeGrid.SelectionController.CurrentCellManager.oldCellValue;
var newCellValue = renderer.GetControlValue();
var treeNode = treeGrid.View.Nodes.GetNode(dataRow.RowData);
if (this.RaiseCurrentCellValidatingEvent(oldValue, newCellValue, columnBase.TreeGridColumn, out changedNewValue, currentCellIndex, columnBase.ColumnElement as FrameworkElement, out errorMessage, dataRow.RowData, treeNode))
{
bool isValid = true;
if (newCellValue != changedNewValue)
{
renderer.SetControlValue(changedNewValue);
}
if (allowattributeValidation)
{
if ((columnBase.ColumnElement is TreeGridCell) && (columnBase.ColumnElement as TreeGridCell).Content != null && (columnBase.ColumnElement as TreeGridCell).Content is FrameworkElement)
{
renderer.UpdateSource((columnBase.ColumnElement as TreeGridCell).Content as FrameworkElement);
}
if (columnBase.TreeGridColumn.GridValidationMode != GridValidationMode.None)
{
isValid = this.treeGrid.ValidationHelper.ValidateColumn(dataRow.RowData, columnBase.TreeGridColumn.MappingName, (columnBase.ColumnElement as TreeGridCell), currentCellIndex) &&
TreeGridDataValidation.Validate((columnBase.ColumnElement as TreeGridCell), columnBase.TreeGridColumn.MappingName, columnBase.ColumnElement.DataContext);
}
#if WPF
if (!isValid && columnBase.TreeGridColumn.GridValidationMode == GridValidationMode.InEdit)
{
return(false);
}
#endif
}
this.RaiseCurrentCellValidatedEvent(oldValue, columnBase.Renderer.GetControlValue(), columnBase.TreeGridColumn, errorMessage, dataRow.RowData, treeNode);
SetCurrentCellValidated(true);
return(true);
}
return(false);
}
/// <summary>
/// Add the Renderes to the Renderer dictionary.
/// </summary>
/// <param name="key"></param>
/// <param name="renderer"></param>
/// <remarks></remarks>
public void Add(string key, ITreeGridCellRenderer renderer)
{
this.content.Add(key, renderer);
}
