public IBindingContextItem ContextItemFactory(IBindingContextElement owner)
{
string name;
IBindingContextItem nestedContextItem = NestedBindingDefinition?.ContextItemFactory(owner);
if (nameBindingDefinition != null)
{
object obj = nameBindingDefinition.ResolveBinding(owner.DataSource);
name = rootName.EmptyIfNull() + (obj?.ToString() ?? string.Empty);
}
else
{
if (usePos)
{
name = definition.Name.Replace(POS_KEYWORD, "_" + owner == null ? string.Empty : owner.Index.ToString());
}
else if (useAllPos)
{
StringBuilder nameBuilder = new StringBuilder();
IBindingContextElement currentOwner = owner;
while (currentOwner != null)
{
nameBuilder.Insert(0, "_" + currentOwner.Index);
currentOwner = currentOwner.ParentPart.ParentContext.Parent;
}
nameBuilder.Insert(0, definition.Name.Replace(ALL_POS_KEYWORD, string.Empty));
name = nameBuilder.ToString();
}
else
{
name = definition.Name;
}
}
return(new ExcelContextItemNamedRange(owner, name, this, nestedContextItem));
}
public override void Invoke(object sender, IBindingContextElement catchingContextElement, IBindingContextItem currentContextItem)
{
object[] methodParams = null;
if (Parameters != null && Parameters.Any())
{
methodParams = new object[Parameters.Count()];
int i = 0;
foreach (SpecificEventCallbackParameter param in Parameters)
{
if (param.IsSender)
{
methodParams[i++] = sender;
continue;
}
if (param.IsCatchingContextElement)
{
methodParams[i++] = catchingContextElement;
continue;
}
if (param.IsCurrentContextItem)
{
methodParams[i++] = currentContextItem;
continue;
}
methodParams[i++] = param.ParameterValue;
}
}
Callback.Invoke(null, methodParams);
}
public void CreateControl(IBindingContextItem item, ref ExcelInterop.Range range)
{
string values;
if (!enumByType.TryGetValue(item.BindingDefinition.BindingType, out values))
{
Type type = item.BindingDefinition.IsNullable ? item.BindingDefinition.BindingType.GetGenericArguments()[0] : item.BindingDefinition.BindingType;
List <string> list = new List <string>();
if (item.BindingDefinition.IsNullable)
{
list.Add(string.Empty);
}
list.AddRange(Enum.GetNames(type).OrderBy(s => s));
string separator = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator;
values = string.Join(separator, list);
enumByType[item.BindingDefinition.BindingType] = values;
}
range.Validation.Add(ExcelInterop.XlDVType.xlValidateList,
ExcelInterop.XlDVAlertStyle.xlValidAlertInformation,
ExcelInterop.XlFormatConditionOperator.xlBetween,
values,
Type.Missing);
range.Validation.IgnoreBlank = false;
range.Validation.InCellDropdown = true;
}
public static void SortDescending(ExcelTemplateView view, IBindingContextItem contextItem)
{
ITemplateDefinition templateDefinition = contextItem.ParentElement.ParentPart.TemplateDefinitionPart.Parent;
ISorterDefinition sortDefinition = SortDefinitionFactory.CreateInstance(templateDefinition, contextItem.BindingDefinition, true, false);
ExecuteSort(view, sortDefinition);
}
private void OnNotifyPropertyChanged(IBindingContextItem contextItem, object param)
{
if (!IsDisposed && !IsClearing)
{
((ExcelTemplateManager)ETKExcel.TemplateManager).ExcelNotifyPropertyManager.NotifyPropertyChanged(new ExcelNotityPropertyContext(contextItem, View, (KeyValuePair <int, int>)param));
}
}
public ExcelNotityPropertyContext(IBindingContextItem contextItem, ExcelTemplateView view, KeyValuePair <int, int> param, bool changeColor = false)
{
ContextItem = contextItem;
View = view;
Param = param;
ChangeColor = changeColor;
}
public ExcelContextItemNamedRange(IBindingContextElement parent, string name, IBindingDefinition bindingDefinition, IBindingContextItem nestedContextItem)
: base(parent, bindingDefinition)
{
this.name = name;
excelBindingDefinitionNamedRange = bindingDefinition as ExcelBindingDefinitionNamedRange;
CanNotify = excelBindingDefinitionNamedRange.CanNotify;
NestedContextItem = nestedContextItem;
}
public void CreateControl(IBindingContextItem item, ref ExcelInterop.Range range, ref ExcelInterop.Range source, ref int vOffset)
{
try
{
int hOffset = 1;
if (item.BindingDefinition.MultiLineFactorResolver != null)
{
if (!item.BindingDefinition.MultiLineFactorResolver.IsNotDotNet)
{
object toInvoke = item.BindingDefinition.MultiLineFactorResolver.Callback.IsStatic ? null : item.ParentElement.DataSource;
if (toInvoke != null)
{
object[] parameters = item.BindingDefinition.MultiLineFactorResolver.Callback.GetParameters().Length == 0 ? null : new [] { item.ParentElement.DataSource };
vOffset = (int)item.BindingDefinition.MultiLineFactorResolver.Callback.Invoke(toInvoke, parameters);
if (vOffset <= 0)
{
vOffset = 1;
}
}
}
}
else
{
object objValue = item.ResolveBinding();
if (objValue is string)
{
string value = objValue as string;
int nbrLine = value.Count(c => c.Equals('\n'));
if (nbrLine > 0)
{
vOffset = (int)((nbrLine + 1) * item.BindingDefinition.MultiLineFactor);
}
}
}
if (range.MergeCells)
{
hOffset = range.MergeArea.Columns.Count;
}
IEnumerable <BorderStyle> bordersStyle = RetrieveBorders(source.MergeCells ? source.MergeArea : source);
ExcelInterop.Range toMerge = range.Resize[vOffset, hOffset];
toMerge.Merge();
foreach (BorderStyle borderStyle in bordersStyle)
{
toMerge.Borders[borderStyle.Index].ColorIndex = borderStyle.ColorIndex;
toMerge.Borders[borderStyle.Index].Weight = borderStyle.Weight;
toMerge.Borders[borderStyle.Index].LineStyle = borderStyle.LineStyle;
toMerge.Borders[borderStyle.Index].Color = borderStyle.Color;
toMerge.Borders[borderStyle.Index].TintAndShade = borderStyle.TintAndShade;
}
}
catch (Exception ex)
{
throw new EtkException($"MultiLine manager failed (option 'ME=' of the cell '{item.BindingDefinition.BindingExpression}': {ex.Message}");
}
}
internal IBindingContextItem GetConcernedContextItem(ExcelInterop.Range target)
{
IBindingContextItem ret = null;
if (IsRendered)
{
ret = Renderer.GetConcernedContextItem(target);
}
return(ret);
}
/// <summary>
/// Manage the views contextual menus (those that are defined in the templates)
/// </summary>
private IEnumerable <IContextualMenu> ManageViewsContextualMenu(ExcelInterop.Worksheet sheet, ExcelInterop.Range range)
{
List <IContextualMenu> menus = new List <IContextualMenu>();
if (sheet != null && range != null)
{
ExcelInterop.Range targetRange = range.Cells[1, 1];
lock (syncRoot)
{
List <ExcelTemplateView> views;
if (viewsBySheet.TryGetValue(sheet, out views))
{
if (views != null)
{
foreach (ExcelTemplateView view in views.Where(v => v.IsRendered).Select(v => v))
{
ExcelInterop.Range intersect = ExcelApplication.Application.Intersect(view.RenderedRange, targetRange);
if (intersect != null)
{
IBindingContextItem currentContextItem = view.GetConcernedContextItem(targetRange);
if (currentContextItem != null)
{
// User contextual menu
IBindingContextElement catchingContextElement = currentContextItem.ParentElement;
do
{
ExcelTemplateDefinitionPart currentTemplateDefinition = catchingContextElement.ParentPart.TemplateDefinitionPart as ExcelTemplateDefinitionPart;
if ((currentTemplateDefinition.Parent as ExcelTemplateDefinition).ContextualMenu != null)
{
ContextualMenu contextualMenu = (currentTemplateDefinition.Parent as ExcelTemplateDefinition).ContextualMenu as ContextualMenu;
contextualMenu.SetAction(targetRange, catchingContextElement, currentContextItem.ParentElement);
menus.Insert(0, contextualMenu);
}
catchingContextElement = catchingContextElement.ParentPart.ParentContext == null ? null : catchingContextElement.ParentPart.ParentContext.Parent;
}while (catchingContextElement != null);
// Etk sort, search and filter
IContextualMenu searchSortAndFilterMenu = sortSearchAndFilterMenuManager.GetMenus(view, targetRange, currentContextItem);
if (searchSortAndFilterMenu != null)
{
menus.Insert(0, searchSortAndFilterMenu);
}
}
}
}
}
}
}
//ExcelApplication.ReleaseComObject(targetRange);
targetRange = null;
}
return(menus);
}
public IBindingContextItem GetConcernedContextItem(ExcelInterop.Range target)
{
IBindingContextItem ret = null;
if (!IsDisposed && !IsClearing)
{
if (contextItems != null)
{
ret = contextItems[target.Row - View.FirstOutputCell.Row, target.Column - View.FirstOutputCell.Column];
}
}
return(ret);
}
public bool OnDataChanged(ExcelInterop.Range target)
{
bool ret = false;
if (!IsDisposed && !IsClearing && contextItems != null)
{
FreezeExcel freezeExcel = null;
try
{
foreach (ExcelInterop.Range cell in target.Cells)
{
IBindingContextItem contextItem = null;
// Because of the merge cells ...
try
{ contextItem = contextItems[cell.Row - View.FirstOutputCell.Row, cell.Column - View.FirstOutputCell.Column]; }
catch
{ }
if (contextItem != null)
{
object retValue;
bool mustUpdate = contextItem.UpdateDataSource(cell.Value2, out retValue);
if (mustUpdate)
{
if (freezeExcel == null)
{
freezeExcel = new FreezeExcel(ETKExcel.ExcelApplication.KeepStatusVisible);
}
//if (!object.Equals(cell.Value2, retValue))
cell.Value2 = retValue;
}
if (!(contextItem is BindingFilterContextItem))
{
ret = true;
}
}
}
}
finally
{
if (freezeExcel != null)
{
freezeExcel.Dispose();
}
}
}
return(ret);
}
// To redo !!!!
private void ManageTemplatePart(ref int cpt, IBindingContextElement contextElement, List <IBindingContextItem> col, int colId, int startPos, int endPos)
{
ExcelInterop.Worksheet worksheetFrom = partToRenderDefinition.DefinitionFirstCell.Worksheet;
ExcelInterop.Worksheet worksheetTo = currentRenderingTo.Worksheet;
int gap = endPos - startPos;
ExcelInterop.Range source = worksheetFrom.Cells[partToRenderDefinition.DefinitionFirstCell.Row + startPos, partToRenderDefinition.DefinitionFirstCell.Column + colId];
source = source.Resize[gap, 1];
ExcelInterop.Range workingRange = currentRenderingTo.Resize[gap, 1];
source.Copy(workingRange);
for (int rowId = startPos; rowId < endPos; rowId++)
{
IBindingContextItem item = partToRenderDefinition.DefinitionParts[colId, rowId] == null ? null : contextElement.BindingContextItems[cpt++];
if (item != null && ((item.BindingDefinition != null && item.BindingDefinition.IsEnum) || item is IExcelControl))
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row + rowId, currentRenderingTo.Column];
if (item.BindingDefinition.IsEnum && !item.BindingDefinition.IsReadOnly)
{
enumManager.CreateControl(item, ref range);
}
else
{
((IExcelControl)item).CreateControl(range);
}
range = null;
}
col.Add(item);
}
ExcelApplication.ReleaseComObject(worksheetFrom);
ExcelApplication.ReleaseComObject(worksheetTo);
worksheetFrom = null;
worksheetTo = null;
//ExcelApplication.ReleaseComObject(source);
//ExcelApplication.ReleaseComObject(workingRange);
source = null;
workingRange = null;
}
internal bool OnBeforeBoubleClick(ExcelInterop.Range target, ref bool cancel)
{
ExcelInterop.Range intersect = ETKExcel.ExcelApplication.Application.Intersect(RenderedRange, target);
if (intersect == null)
{
return(false);
}
IBindingContextItem currentContextItem = GetConcernedContextItem(target);
if (currentContextItem?.BindingDefinition != null)
{
if (currentContextItem.BindingDefinition.IsReadOnly)
{
cancel = true;
}
// If the bound excelBindingDefinition contains a left double click callback: invoke it !
if (currentContextItem.BindingDefinition.OnClick != null)
{
((ExcelTemplateManager)ETKExcel.TemplateManager).CallbacksManager.Invoke(currentContextItem.BindingDefinition.OnClick,
target, currentContextItem.ParentElement, currentContextItem);
cancel = true;
}
else
{
IBindingContextElement currentContextElement = currentContextItem.ParentElement;
if (currentContextElement != null && currentContextElement.ParentPart != null && currentContextElement.ParentPart.PartType == BindingContextPartType.Header &&
((TemplateDefinition)currentContextElement.ParentPart.TemplateDefinitionPart.Parent).TemplateOption.HeaderAsExpander != HeaderAsExpander.None)
{
if (CheckHeaderAsExpander(Renderer, target))
{
cancel = true;
}
}
}
}
intersect = null;
return(true);
}
public ExcelContextItemWithFormula(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
excelBindingDefinitionWithFormula = bindingDefinition as ExcelBindingDefinitionWithFormula;
CanNotify = excelBindingDefinitionWithFormula.CanNotify;
if (excelBindingDefinitionWithFormula.FormulaBindingDefinition != null)
{
formulaBindingContext = excelBindingDefinitionWithFormula.FormulaBindingDefinition.ContextItemFactory(parent);
}
if (CanNotify)
{
objectsToNotify = excelBindingDefinitionWithFormula.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
}
/// <summary> Invoke the decorator</summary>
/// <param name="sender">Range that ask for a decoration</param>
/// <param name="contextItem">Binding bindingContextPart of the decoration request</param>
/// <returns>True if decorator is resolved</returns>
public override bool Resolve(object sender, IBindingContextItem contextItem)
{
ExcelInterop.Range concernedRange = sender as ExcelInterop.Range;
if (concernedRange == null)
{
return(false);
}
try
{
// We delete the previous concernedRange comment
ExcelInterop.Comment comment = concernedRange.Comment;
comment?.Delete();
// Invoke decorator resolver
object result = EventCallbacksManager.DecoratorInvoke(Callback, concernedRange, contextItem.DataSource, contextItem.BindingDefinition.Name);
if (result != null)
{
string commentStr = result as string;
if (!string.IsNullOrEmpty(commentStr))
{
concernedRange.AddComment(commentStr);
ExcelInterop.Comment addedComment = concernedRange.Comment;
ExcelInterop.Shape shape = addedComment.Shape;
ExcelInterop.TextFrame textFrame = shape.TextFrame;
textFrame.AutoSize = true;
}
return(commentStr != null);
}
return(false);
}
catch (Exception ex)
{
log.LogExceptionFormat(LogType.Error, ex, $"Cannot resolve simple decorator '{Ident}':{ex.Message}");
return(false);
}
}
public void RenderDataOnly()
{
if (IsDisposed || RenderedRange == null)
{
return;
}
contextItems = new IBindingContextItem[RenderedArea.Height, RenderedArea.Width];
cells = new object[RenderedArea.Height, RenderedArea.Width];
ConcurrentStack <KeyValuePair <IBindingContextItem, System.Drawing.Point> > decorators = new ConcurrentStack <KeyValuePair <IBindingContextItem, System.Drawing.Point> >();
//Parallel.For(0, DataRows.Count, i => // Parrallel problem with Com object
for (int i = 0; i < DataRows.Count; i++)
{
int colId = 0;
List <IBindingContextItem> itemsInRow = DataRows[i];
foreach (IBindingContextItem item in itemsInRow)
{
if (item != null)
{
if (item.BindingDefinition != null && item.BindingDefinition.DecoratorDefinition != null)
{
decorators.Push(new KeyValuePair <IBindingContextItem, System.Drawing.Point>(item, new System.Drawing.Point(colId + 1, i + 1)));
}
contextItems[i, colId] = item;
if (item.CanNotify)
{
((IBindingContextItemCanNotify)item).OnPropertyChangedAction = OnNotifyPropertyChanged;
((IBindingContextItemCanNotify)item).OnPropertyChangedActionArgs = new KeyValuePair <int, int>(i, colId);
}
object value = item.ResolveBinding();
cells[i, colId++] = (value as Enum)?.ToString() ?? value;
}
else
{
cells[i, colId++] = null;
}
}
}
//);
RenderedRange.Value2 = cells;
// Element decorators managements
foreach (ExcelElementDecorator rowDecorator in RowDecorators)
{
rowDecorator.Resolve();
}
// Decorators managements
foreach (KeyValuePair <IBindingContextItem, System.Drawing.Point> kvp in decorators)
{
ExcelInterop.Range range = RenderedRange[kvp.Value.Y, kvp.Value.X];
kvp.Key.BindingDefinition.DecoratorDefinition.Resolve(range, kvp.Key);
range = null;
}
// Redraw the borders of the current selection
if (((TemplateDefinition)View.TemplateDefinition).AddBorder)
{
BorderAround(RenderedRange, ExcelInterop.XlLineStyle.xlContinuous, ExcelInterop.XlBorderWeight.xlMedium, 1);
}
}
private void ManageTemplatePart(RenderingContext renderingContext, ref int currentBindingContextItemId, ref int vOffset, int startPos, int endPos)
{
ExcelInterop.Worksheet worksheetFrom = partToRenderDefinition.DefinitionFirstCell.Worksheet;
ExcelInterop.Worksheet worksheetTo = currentRenderingTo.Worksheet;
int gap = endPos - startPos;
ExcelInterop.Range source = worksheetFrom.Cells[partToRenderDefinition.DefinitionFirstCell.Row + renderingContext.RowId, partToRenderDefinition.DefinitionFirstCell.Column + startPos];
source = source.Resize[1, gap];
ExcelInterop.Range workingRange = currentRenderingTo.Resize[1, gap];
source.Copy(workingRange);
int bindingContextItemsCount = renderingContext.ContextElement.BindingContextItems.Count;
for (int colId = startPos; colId < endPos; colId++)
{
IBindingContextItem item = partToRenderDefinition.DefinitionParts[renderingContext.RowId, colId] == null || bindingContextItemsCount <= currentBindingContextItemId
? null
: renderingContext.ContextElement.BindingContextItems[currentBindingContextItemId++];
if (item != null)
{
if (item is ExcelBindingSearchContextItem)
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row, currentRenderingTo.Column + colId - startPos];
((ExcelBindingSearchContextItem)item).SetRange(ref range);
range = null;
}
else if (item is IExcelControl)
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row, currentRenderingTo.Column + colId - startPos];
((IExcelControl)item).CreateControl(range);
range = null;
}
if (item.BindingDefinition != null)
{
if (item.BindingDefinition.IsEnum && !item.BindingDefinition.IsReadOnly)
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row, currentRenderingTo.Column + colId - startPos];
enumManager.CreateControl(item, ref range);
range = null;
}
if (item.BindingDefinition.IsMultiLine)
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row, currentRenderingTo.Column + colId - startPos];
ExcelInterop.Range localSource = source[1, 1 + colId - startPos];
multiLineManager.CreateControl(item, ref range, ref localSource, ref vOffset);
range = null;
}
if (item.BindingDefinition.OnAfterRendering != null)
{
ExcelInterop.Range range = worksheetTo.Cells[currentRenderingTo.Row, currentRenderingTo.Column + colId - startPos];
AddAfterRenderingAction(item.BindingDefinition, range);
range = null;
}
}
}
renderingContext.DataRow.Add(item);
}
source = null;
workingRange = null;
ExcelApplication.ReleaseComObject(worksheetFrom);
ExcelApplication.ReleaseComObject(worksheetTo);
worksheetFrom = null;
worksheetTo = null;
}
protected override void ManageTemplateWithoutLinkedTemplates()
{
ExcelInterop.Range firstCell = currentRenderingTo;
ExcelInterop.Worksheet worksheetTo = currentRenderingTo.Worksheet;
int cptElements = 0;
int nbrOfElement = bindingContextPart.ElementsToRender.Count();
int localWidth = partToRenderDefinition.Width;
int localHeight = partToRenderDefinition.Height * nbrOfElement;
if (localHeight > 0)
{
ExcelInterop.Range workingRange = currentRenderingTo.Resize[localHeight, localWidth];
partToRenderDefinition.DefinitionCells.Copy(workingRange);
currentRenderingTo = worksheetTo.Cells[currentRenderingTo.Row + localHeight, currentRenderingTo.Column + localWidth];
foreach (IBindingContextElement contextElement in bindingContextPart.ElementsToRender)
{
int cptItems = 0;
for (int rowId = 0; rowId < partToRenderDefinition.Height; rowId++)
{
List <IBindingContextItem> row = new List <IBindingContextItem>();
Parent.DataRows.Add(row);
for (int colId = 0; colId < partToRenderDefinition.Width; colId++)
{
IBindingContextItem item = partToRenderDefinition.DefinitionParts[rowId, colId] == null ? null : contextElement.BindingContextItems[cptItems++];
if (item != null)
{
if (item is ExcelBindingSearchContextItem)
{
ExcelInterop.Range range = worksheetTo.Cells[firstCell.Row + rowId + cptElements * partToRenderDefinition.Height, firstCell.Column + colId];
((ExcelBindingSearchContextItem)item).SetRange(ref range);
range = null;
}
else if (item is IExcelControl)
{
ExcelInterop.Range range = worksheetTo.Cells[firstCell.Row + rowId + cptElements * partToRenderDefinition.Height, firstCell.Column + colId];
((IExcelControl)item).CreateControl(range);
range = null;
}
else if (item.BindingDefinition != null)
{
if (item.BindingDefinition.IsEnum && !item.BindingDefinition.IsReadOnly)
{
ExcelInterop.Range range = worksheetTo.Cells[firstCell.Row + rowId + cptElements * partToRenderDefinition.Height, firstCell.Column + colId];
enumManager.CreateControl(item, ref range);
range = null;
}
if (item.BindingDefinition.OnAfterRendering != null)
{
ExcelInterop.Range range = worksheetTo.Cells[firstCell.Row + rowId + cptElements * partToRenderDefinition.Height, firstCell.Column + colId];
AddAfterRenderingAction(item.BindingDefinition, range);
range = null;
}
}
}
row.Add(item);
}
}
if (useDecorator && ((ExcelTemplateDefinition)partToRenderDefinition.Parent).Decorator != null)
{
ExcelInterop.Range elementRange = firstCell.Offset[cptElements, 0];
elementRange = elementRange.Resize[1, localWidth];
Parent.RootRenderer.RowDecorators.Add(new ExcelElementDecorator(elementRange, ((ExcelTemplateDefinition)partToRenderDefinition.Parent).Decorator, contextElement));
}
cptElements++;
}
//ExcelApplication.ReleaseComObject(workingRange);
workingRange = null;
}
// To take into account the min number of elements to render.
if (Parent.MinOccurencesMethod != null)
{
IBindingContextElement parentElement = null;
if (bindingContextPart.ParentContext != null)
{
parentElement = bindingContextPart.ParentContext.Parent;
}
int minElementsToRender = LinkedTemplateDefinition.ResolveMinOccurences(Parent.MinOccurencesMethod, parentElement);
if (minElementsToRender > nbrOfElement)
{
localHeight = partToRenderDefinition.Height * minElementsToRender;
}
}
Height += localHeight;
if (Width < localWidth)
{
Width = localWidth;
}
firstCell = null;
ExcelApplication.ReleaseComObject(worksheetTo);
worksheetTo = null;
}
protected override void ManageTemplateWithoutLinkedTemplates()
{
ExcelInterop.Range firstCell = currentRenderingTo;
ExcelInterop.Worksheet worksheetTo = currentRenderingTo.Worksheet;
int cptElements = 0;
int nbrOfElement = bindingContextPart.ElementsToRender.Count();
int localWidth = partToRenderDefinition.Width * nbrOfElement;
int localHeight = partToRenderDefinition.Height;
if (nbrOfElement > 0)
{
ExcelInterop.Range workingRange = currentRenderingTo.Resize[localHeight, localWidth];
partToRenderDefinition.DefinitionCells.Copy(workingRange);
currentRenderingTo = worksheetTo.Cells[currentRenderingTo.Row + localHeight, currentRenderingTo.Column + localWidth];
for (int rowId = 0; rowId < partToRenderDefinition.Height; rowId++)
{
Parent.DataRows.Add(new List <IBindingContextItem>());
}
foreach (IBindingContextElement contextElement in bindingContextPart.ElementsToRender)
{
int cptItems = 0;
for (int rowId = 0; rowId < partToRenderDefinition.Height; rowId++)
{
for (int colId = 0; colId < partToRenderDefinition.Width; colId++)
{
IBindingContextItem item = partToRenderDefinition.DefinitionParts[rowId, colId] == null ? null : contextElement.BindingContextItems[cptItems++];
if (item != null && ((item.BindingDefinition != null && item.BindingDefinition.IsEnum && !item.BindingDefinition.IsReadOnly) || item is IExcelControl))
{
ExcelInterop.Range range = worksheetTo.Cells[firstCell.Row + rowId, firstCell.Column + colId + cptElements * partToRenderDefinition.Width];
if (item.BindingDefinition.IsEnum)
{
enumManager.CreateControl(item, ref range);
}
else
{
((IExcelControl)item).CreateControl(range);
}
range = null;
}
Parent.DataRows[rowId].Add(item);
}
}
if (useDecorator && ((ExcelTemplateDefinition)this.partToRenderDefinition.Parent).Decorator != null)
{
ExcelInterop.Range elementRange = firstCell.Offset[0, cptElements];
elementRange = elementRange.Resize[localHeight, 1];
Parent.RootRenderer.RowDecorators.Add(new ExcelElementDecorator(elementRange, ((ExcelTemplateDefinition)partToRenderDefinition.Parent).Decorator, contextElement));
}
cptElements++;
}
workingRange = null;
//ExcelApplication.ReleaseComObject(workingRange);
}
// To take into account the min number of elements to render.
if (Parent.MinOccurencesMethod != null)
{
IBindingContextElement parentElement = null;
if (bindingContextPart.ParentContext != null)
{
parentElement = bindingContextPart.ParentContext.Parent;
}
int minElementsToRender = LinkedTemplateDefinition.ResolveMinOccurences(Parent.MinOccurencesMethod, parentElement);
if (minElementsToRender > nbrOfElement)
{
localWidth = partToRenderDefinition.Width * minElementsToRender;
IBindingContextItem[] toAdd = new IBindingContextItem[minElementsToRender - nbrOfElement];
if (Parent.DataRows.Count == 0)
{
for (int rowId = 0; rowId < partToRenderDefinition.Height; rowId++)
{
Parent.DataRows.Add(new List <IBindingContextItem>());
}
}
for (int rowId = 0; rowId < partToRenderDefinition.Height; rowId++)
{
Parent.DataRows[rowId].AddRange(toAdd);
}
}
}
Width += localWidth;
if (Height < localHeight)
{
Height = localHeight;
}
ExcelApplication.ReleaseComObject(worksheetTo);
firstCell = null;
}
/// <summary>
/// Manage the contextual menus
/// </summary>
public IContextualMenu GetMenus(ExcelTemplateView view, Microsoft.Office.Interop.Excel.Range range, IBindingContextItem contextItem)
{
IBindingDefinition bindingDefinition = contextItem.BindingDefinition;
if (bindingDefinition == null || !bindingDefinition.IsBoundWithData || bindingDefinition.BindingType == null)
{
return(null);
}
if (!((TemplateDefinition)contextItem.ParentElement.ParentPart.ParentContext.TemplateDefinition).CanSort)
{
return(null);
}
foreach (IContextualPart menuPart in sortSearchAndFilersMenu.Items)
{
ContextualMenuItem menuItem = menuPart as ContextualMenuItem;
menuItem.SetAction(() => menuItem.MethodInfo.Invoke(null, new object[] { view, contextItem }));
}
return(sortSearchAndFilersMenu);
}
public abstract bool Resolve(object sender, IBindingContextItem contextItem);
internal bool OnSelectionChange(ExcelInterop.Range target)
{
try
{
CurrentSelectedCell = null;
if (UseHighlightSelection)
{
UnhighlightSelection();
}
if (IsRendered)
{
ExcelInterop.Range intersect = ETKExcel.ExcelApplication.Application.Intersect(RenderedRange, target);
if (intersect != null)
{
CurrentSelectedCell = target.Cells[1, 1];
IBindingContextItem currentContextItem = GetConcernedContextItem(target);
if (currentContextItem?.BindingDefinition != null)
{
// If the binding excelBindingDefinition contains a selection callback: invoke it !
if (currentContextItem.BindingDefinition.OnSelection != null)
{
((ExcelTemplateManager)ETKExcel.TemplateManager).CallbacksManager.Invoke(currentContextItem.BindingDefinition.OnSelection,
target, currentContextItem.ParentElement, currentContextItem);
}
else
{
// Ask the containing template (and its owner and the owner of its owner etc.... => bubble up the event)) if they contain a selection callback
// Invoke the first found
IBindingContextElement catchingContextElement = currentContextItem.ParentElement;
bool isResolved = false;
do
{
ExcelTemplateDefinitionPart currentTemplateDefinition = catchingContextElement.ParentPart.TemplateDefinitionPart as ExcelTemplateDefinitionPart;
if (currentTemplateDefinition.PartType == TemplateDefinitionPartType.Body)
{
EventCallback callback = (currentTemplateDefinition.Parent as ExcelTemplateDefinition).SelectionChanged;
if (callback != null)
{
((ExcelTemplateManager)ETKExcel.TemplateManager).CallbacksManager.Invoke(callback, target, catchingContextElement, currentContextItem);
isResolved = true;
}
}
if (!isResolved)
{
catchingContextElement = catchingContextElement.ParentPart.ParentContext?.Parent;
}
}while (!isResolved && catchingContextElement != null);
}
}
intersect = null;
if (UseHighlightSelection)
{
HighlightSelection(target);
}
}
}
}
catch (Exception ex)
{
string message = $"Sheet '{target.Worksheet.Name}', Template '{TemplateDefinition.Name}' 'OnSelectionChange' failed: '{ex.Message}'";
log.LogException(LogType.Error, ex, message);
}
return(CurrentSelectedCell != null);
}
public void Invoke(EventCallback callback, object sender, IBindingContextElement catchingContextElement, IBindingContextItem currentContextItem)
{
if (callback.IsNotDotNet)
{
InvokeNotDotNet(callback, new [] { catchingContextElement?.DataSource, currentContextItem?.BindingDefinition?.Name });
}
callback.Invoke(sender, catchingContextElement, currentContextItem);
}
public virtual void Invoke(object sender, IBindingContextElement catchingContextElement, IBindingContextItem currentContextItem)
{
object invokeTarget = Callback.IsStatic ? null : catchingContextElement.DataSource;
int nbrParameters = Callback.GetParameters().Length;
if (nbrParameters > 3)
{
throw new Exception($"Method info '{Callback.Name}' signature is not correct");
}
object[] parameters;
switch (nbrParameters)
{
//case 4:
// parameters = new object[] { catchingContextElement, catchingContextElement.DataSource, currentContextItem, currentContextItem.DataSource };
// break;
case 3:
parameters = new[] { sender, catchingContextElement.DataSource, currentContextItem.ParentElement.DataSource };
break;
case 2:
if (Callback.GetParameters()[0].ParameterType == typeof(ITemplateView))
{
parameters = new[] { catchingContextElement.ParentPart.ParentContext.Owner, catchingContextElement.DataSource }
}
;
else
{
parameters = new[] { catchingContextElement.DataSource, currentContextItem.ParentElement.DataSource }
};
break;
case 1:
parameters = new[] { catchingContextElement.DataSource };
break;
default:
parameters = null;
break;
}
Callback.Invoke(invokeTarget, parameters);
}
private void Init()
{
try
{
bool createElement = ParentPart.TemplateDefinitionPart.Parent.BindingType != null && (ParentPart.ExternalSorterAndFilter != null || ParentPart.ParentContext.TemplatedFilters != null || ((TemplateView)ParentPart.ParentContext.Owner).SorterDefinition != null);
if (createElement)
{
Element = Activator.CreateInstance(ParentPart.TemplateDefinitionPart.Parent.BindingType.BindType);
}
List <BindingFilterContextItem> newTemplatesFilters = null;
foreach (IDefinitionPart definitionPart in ParentPart.TemplateDefinitionPart.BindingParts)
{
if (definitionPart != null)
{
switch (definitionPart.PartType)
{
case BindingPartType.BindingDefinition:
IBindingContextItem item = ((IBindingDefinition)definitionPart).ContextItemFactory(this);
BindingContextItems.Add(item);
break;
case BindingPartType.FilterDefinition:
BindingFilterContextItem filter = ((BindingFilterDefinition)definitionPart).CreateContextItem(ParentPart.ParentContext.Owner, this);
if (newTemplatesFilters == null)
{
newTemplatesFilters = new List <BindingFilterContextItem>();
}
BindingContextItems.Add(filter);
if (!string.IsNullOrEmpty(filter.FilterExpression))
{
newTemplatesFilters.Add(filter);
}
break;
case BindingPartType.SearchDefinition:
BindingSearchContextItem search = ((BindingSearchDefinition)definitionPart).CreateContextItem(ParentPart.ParentContext.Owner, this);
BindingContextItems.Add(search);
break;
}
}
}
//#if DEBUG
LinkedBindingContexts = new List <IBindingContext>();
foreach (ILinkedTemplateDefinition lt in ParentPart.TemplateDefinitionPart.LinkedTemplates)
{
object resolvedBinding = lt.ResolveBinding(DataSource);
List <IFilterDefinition> templatedFilters = null;
if (newTemplatesFilters == null)
{
templatedFilters = ParentPart.ParentContext.TemplatedFilters;
}
else
{
templatedFilters = new List <IFilterDefinition>();
if (ParentPart.ParentContext.TemplatedFilters != null)
{
templatedFilters.AddRange(ParentPart.ParentContext.TemplatedFilters);
}
templatedFilters.AddRange(newTemplatesFilters);
}
BindingContext linkedContext = new BindingContext(this, ParentPart.ParentContext.Owner, lt.TemplateDefinition, resolvedBinding, templatedFilters);
LinkedBindingContexts.Add(linkedContext);
}
//#else
// IBindingContext[] contexts = new IBindingContext[ParentElement.FilterOwner.LinkedTemplates.Count];
// if (contexts.Any())
// {
// Parallel.For(0, ParentElement.DefinitionToFilterOwner.Body.LinkedTemplates.Count, i =>
// {
// ILinkedTemplateDefinition lt = ParentElement.DefinitionToFilterOwner.Body.LinkedTemplates[i];
// object resolvedBinding = lt.ResolveBinding(DataSource);
// contexts[i] = new BindingContext(this, lt.DefinitionToFilterOwner, resolvedBinding, externalSortsAndFilters);
// });
// }
// LinkedBindingContexts = contexts.ToList();
//#endif
}
catch (Exception ex)//@@
{
throw ex;
}
}
