private void AsEditRow(GridItem item, bool current)
{
if (current && creatorData.Mode == GridItemMode.Edit)
{
item.Type = GridItemType.EditRow;
}
}
public GridItem CreateItem(object dataItem)
{
var item = new GridItem
{
DataItem = dataItem,
State = GridItemStates.Default,
Type = GridItemType.DataRow
};
if (dataItem is IGroup)
{
AsGroupRow(item);
}
else
{
var current = comparer.KeysEqualTo(dataItem);
AsEditRow(item, current);
AsSelected(item, current);
AsMaster(item);
}
return item;
}
private void AsMaster(GridItem item)
{
if (creatorData.HasDetailView)
{
item.State |= GridItemStates.Master;
}
}
private void AsSelected(GridItem item, bool current)
{
if (current && creatorData.Mode == GridItemMode.Select)
{
item.State |= GridItemStates.Selected;
}
}
protected virtual IGridRowBuilder CreateDataRowBuilder(GridRenderingData renderingData, GridItem item)
{
if (renderingData.RowTemplate != null)
{
return new GridTemplateRowBuilder(td => renderingData.RowTemplate(item.DataItem, td), renderingData.Colspan);
}
return new GridDataRowBuilder(item.DataItem, renderingData.Columns.Select(column => cellBuilderFactory.CreateDisplayCellBuilder(column, renderingData.HtmlHelper)));
}
public IGridRowBuilder CreateBuilder(GridRenderingData renderingData, GridItem item)
{
var creator = BuilderRegistry[item.Type];
ExecuteRowCallback(item, renderingData.Callback);
var gridRowBuilder = creator(renderingData, item);
return decoratorProvider.ApplyDecorators(gridRowBuilder, item, renderingData.HasDetailView);
}
public IGridRowBuilder ApplyDecorators(IGridRowBuilder gridRowBuilder, GridItem item, bool hasDetailView)
{
var builderToDecorate = gridRowBuilder;
foreach (var decorator in decorators)
{
var temp = decorator();
temp.Decorate(builderToDecorate, item, hasDetailView);
builderToDecorate = temp;
}
return builderToDecorate;
}
public virtual IGridRowBuilder CreateHeaderBuilder(GridRenderingData renderingData)
{
var builder = new GridRowBuilder(renderingData.Columns.Select(cellBuilderFactory.CreateHeaderCellBuilder));
var item = new GridItem
{
GroupLevel = renderingData.GroupMembers.Count(),
Type = GridItemType.HeaderRow
};
return decoratorProvider.ApplyDecorators(builder, item, renderingData.HasDetailView);
}
private void ExecuteRowCallback(GridItem item, Action<GridItem> callback)
{
if (item.Type != GridItemType.DetailRow
&& item.Type != GridItemType.GroupRow
&& item.Type != GridItemType.GroupFooterRow
&& item.Type != GridItemType.EmptyRow)
{
callback(item);
}
}
protected virtual IGridRowBuilder CreateGroupRowBuilder(GridRenderingData renderingData, GridItem item)
{
var groupKey = ((IGroup) item.DataItem).Key;
var colspan = renderingData.Colspan - item.GroupLevel;
var member = renderingData.GroupMembers.ElementAtOrDefault(item.GroupLevel);
var column = renderingData.Columns.OfType<IGridBoundColumn>().FirstOrDefault(c => c.Member == member);
var format = column != null && column.Format.HasValue() ? column.Format : "{0}";
var template = new HtmlTemplate<GridGroupAggregateResult>
{
InlineTemplate = (result) => "{0}: {1}".FormatWith(result.Title, format.FormatWith(ExtractForeignKeyText(column, result.Key)))
};
var title = member.AsTitle();
if (column != null)
{
title = column.Title.HasValue() ? column.Title : column.Member.AsTitle();
if (column.GroupHeaderTemplate.HasValue())
{
template = column.GroupHeaderTemplate;
}
}
var functionsGroup = item.DataItem as AggregateFunctionsGroup;
var itemAggregateResult = functionsGroup.GetAggregateResults(renderingData.Aggregates);
var aggregateResult = new GridGroupAggregateResult(title, groupKey, itemAggregateResult);
return new GridGroupRowBuilder((container) => template.Apply(aggregateResult, container), colspan);
}
protected virtual IGridRowBuilder CreateGroupFooterRowBuilder(GridRenderingData renderingData, GridItem item)
{
var functionsGroup = item.DataItem as AggregateFunctionsGroup;
var itemAggregateResult = functionsGroup.GetAggregateResults(renderingData.Aggregates);
return new GridGroupFooterRowBuilder(renderingData.Columns.Select(column => cellBuilderFactory.CreateGroupFooterCellBuilder(column, itemAggregateResult)));
}
private void AsGroupRow(GridItem item)
{
item.Type = GridItemType.GroupRow;
}
public override bool ShouldDecorate(GridItem gridItem)
{
return gridItem.Type != GridItemType.EmptyRow;
}
protected virtual IGridRowBuilder CreateDetailRowBuilder(GridRenderingData renderingData, GridItem item)
{
return new GridDetailRowBuilder
{
Colspan = (renderingData.Colspan - 1) - item.GroupLevel,
DataItem = item.DataItem,
Template = renderingData.DetailViewTemplate,
Expanded = item.Expanded,
IsMasterAlternate = item is GridDetailViewItem && ((item as GridDetailViewItem).Parent.State & GridItemStates.Alternating) == GridItemStates.Alternating,
Html = item.DetailRowHtml,
HtmlAttributes = item.DetailRowHtmlAttributes
};
}
protected virtual IGridRowBuilder CreateInFormInsertRowBuilder(GridRenderingData renderingData, GridItem item)
{
return new GridInFormEditRowBuilder(CreateInsertFormBuilder(renderingData, item), renderingData.Colspan);
}
protected virtual IGridRowBuilder CreateInLineInsertRowBuilder(GridRenderingData renderingData, GridItem item)
{
return CreateInLineRowBuilder(renderingData, item, renderingData.UrlBuilder.InsertUrl, cellBuilderFactory.CreateInsertCellBuilder);
}
protected virtual IGridRowBuilder CreateEmptyRowBuilder(GridRenderingData renderingData, GridItem item)
{
return new GridEmptyRowBuilder(renderingData.Colspan, renderingData.NoRecordsTemplate);
}
private IGridRowBuilder CreateInLineRowBuilder(GridRenderingData renderingData, GridItem item, Func<object, string> action, Func<IGridColumn, IGridHtmlHelper, IGridDataCellBuilder> cellBuilder)
{
var tableBuilder = tableBuilderFactory.CreateTableBuilder(renderingData.Columns.Select(c => new GridColData { Width = c.Width, Hidden = c.Hidden }));
var cellBuilders = renderingData.Columns.Select(column => cellBuilder(column, renderingData.HtmlHelper));
var formHtmlAttributes = CreateFormAttributes(renderingData.FormId, action(item.DataItem));
formHtmlAttributes.Merge(renderingData.EditFormHtmlAttributes);
return new GridInLineEditRowBuilder(tableBuilder, new GridFormBuilder(formHtmlAttributes),
renderingData.Colspan, item.DataItem, cellBuilders);
}
private IGridEditFormBuilder CreateEditFormBuilder(GridRenderingData renderingData, GridItem item,
Func<IGridActionCommand, IEnumerable<IGridButtonBuilder>> buttons, Func<object, string> action)
{
var commands = renderingData.Columns.OfType<IGridActionColumn>().SelectMany(column => column.Commands);
var editCommand = commands.OfType<GridEditActionCommand>().FirstOrDefault() ?? new GridEditActionCommand();
var buttonBuilders = buttons(editCommand).Select(builder =>
{
Func<IHtmlNode> result = () => builder.Create(item.DataItem);
return result;
});
var formHtmlAttributes = CreateFormAttributes(renderingData.FormId, action(item.DataItem));
formHtmlAttributes.Merge(renderingData.EditFormHtmlAttributes);
return new GridEditFormBuilder(new GridFormBuilder(formHtmlAttributes),
() => renderingData.HtmlHelper.EditorForModel(item.DataItem,
renderingData.EditTemplateName,
renderingData.Columns.OfType<IGridForeignKeyColumn>().Select(c => c.SerializeSelectList),
renderingData.AdditionalViewData
),
buttonBuilders);
}
protected virtual IGridRowBuilder CreatePopUpInsertRowBuilder(GridRenderingData renderingData, GridItem item)
{
return new GridPopUpInsertRowBuilder(CreateInsertFormBuilder(renderingData, item), renderingData.PopUpContainer);
}
protected virtual IGridRowBuilder CreateInsertRowBuilder(GridRenderingData renderingData, GridItem item)
{
switch (renderingData.EditMode)
{
case GridEditMode.InForm:
return CreateInFormInsertRowBuilder(renderingData, item);
case GridEditMode.PopUp:
return CreatePopUpInsertRowBuilder(renderingData, item);
default:
return CreateInLineInsertRowBuilder(renderingData, item);
}
}
protected virtual IGridEditFormBuilder CreateInsertFormBuilder(GridRenderingData renderingData, GridItem item)
{
return CreateEditFormBuilder(renderingData,
item,
(command) => command.CreateInsertButtons(renderingData.Localization, renderingData.UrlBuilder,
renderingData.HtmlHelper),
renderingData.UrlBuilder.InsertUrl
);
}
public GridItem CreateGroupFooterItem(object dataItem)
{
if (creatorData.ShowGroupFooter)
{
var groupFooter = new GridItem
{
GroupLevel = creatorData.GroupsCount,
DataItem = dataItem,
Type = GridItemType.GroupFooterRow
};
return groupFooter;
}
return null;
}
public override bool ShouldDecorate(GridItem gridItem)
{
return HasDetailView && gridItem.Type != GridItemType.EmptyRow &&
gridItem.Type != GridItemType.GroupRow;
}