/// <summary>
/// Render a hyperlink.
/// </summary>
/// <param name="hyperlink"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static OpenXmlElement Render(this Hyperlink hyperlink,
OpenXmlElement parent,
ContextModel context,
OpenXmlPart documentPart,
IFormatProvider formatProvider)
{
context.ReplaceItem(hyperlink, formatProvider);
if (!hyperlink.Show)
{
return(null);
}
var fieldCodeXmlelement = new DocumentFormat.OpenXml.Wordprocessing.Hyperlink();
if (!string.IsNullOrWhiteSpace(hyperlink.Anchor))
{
fieldCodeXmlelement.Anchor = hyperlink.Anchor;
}
else if (!string.IsNullOrWhiteSpace(hyperlink.WebSiteUri))
{
HyperlinkRelationship hyperlinkPart = documentPart.AddHyperlinkRelationship(new Uri(hyperlink.WebSiteUri), true);
fieldCodeXmlelement.Id = hyperlinkPart.Id;
}
parent.AppendChild(fieldCodeXmlelement);
hyperlink.Text.Render(fieldCodeXmlelement, context, documentPart, formatProvider);
return(fieldCodeXmlelement);
}
/// <summary>
/// Render a label
/// </summary>
/// <param name="label"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
internal static OpenXmlElement Render(this Label label, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, IFormatProvider formatProvider)
{
context.ReplaceItem(label, formatProvider);
if (label.IsHtml)
{
AlternativeFormatImportPart formatImportPart;
if (documentPart is MainDocumentPart)
{
formatImportPart = (documentPart as MainDocumentPart).AddAlternativeFormatImportPart(AlternativeFormatImportPartType.Xhtml);
}
else if (documentPart is HeaderPart)
{
formatImportPart = (documentPart as HeaderPart).AddAlternativeFormatImportPart(AlternativeFormatImportPartType.Xhtml);
}
else if (documentPart is FooterPart)
{
formatImportPart = (documentPart as FooterPart).AddAlternativeFormatImportPart(AlternativeFormatImportPartType.Xhtml);
}
else
{
return(null);
}
return(SetHtmlContent(label, parent, documentPart, formatImportPart));
}
else
{
return(SetTextContent(label, parent));
}
}
/// <summary>
/// Render a foreach page element
/// </summary>
/// <param name="forEach"></param>
/// <param name="document"></param>
/// <param name="wdDoc"></param>
/// <param name="context"></param>
/// <param name="mainDocumentPart"></param>
/// <param name="formatProvider"></param>
public static void Render(this ForEachPage forEach,
Document document,
OpenXmlElement wdDoc,
ContextModel context,
MainDocumentPart mainDocumentPart,
IFormatProvider formatProvider)
{
context.ReplaceItem(forEach, formatProvider);
if (string.IsNullOrEmpty(forEach.DataSourceKey) ||
!context.ExistItem <DataSourceModel>(forEach.DataSourceKey))
{
return;
}
var datasource = context.GetItem <DataSourceModel>(forEach.DataSourceKey);
if (datasource == null || datasource.Items == null)
{
return;
}
int i = 0;
foreach (var item in datasource.Items)
{
var newPage = forEach.Clone();
// doc inherit margin from page
if (document.Margin == null && newPage.Margin != null)
{
document.Margin = newPage.Margin;
}
// newPage inherit margin from doc
else if (document.Margin != null && newPage.Margin == null)
{
newPage.Margin = document.Margin;
}
if (!string.IsNullOrWhiteSpace(forEach.AutoContextAddItemsPrefix))
{
// We add automatic keys :
// Is first item
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IsFirstItem#", new BooleanModel(i == 0));
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IsNotFirstItem#", new BooleanModel(i > 0));
// Is last item
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IsLastItem#", new BooleanModel(i == datasource.Items.Count - 1));
// Index of the element (Based on 0, and based on 1)
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IndexBaseZero#", new StringModel(i.ToString()));
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IndexBaseOne#", new StringModel((i + 1).ToString()));
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IsOdd#", new BooleanModel(i % 2 == 1));
item.AddItem("#" + forEach.AutoContextAddItemsPrefix + "_ForEachPage_IsEven#", new BooleanModel(i % 2 == 0));
}
newPage.Clone().Render(document, wdDoc, item, mainDocumentPart, formatProvider);
i++;
}
}
internal static OpenXmlElement Render(this BaseElement element, Document document, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, IFormatProvider formatProvider)
{
context.ReplaceItem(element, formatProvider);
OpenXmlElement createdElement = null;
if (element.Show)
{
createdElement = element.RenderItem(document, parent, context, documentPart, formatProvider);
}
return(createdElement);
}
/// <summary>
/// Render a ForEach element in the document
/// </summary>
/// <param name="forEach"></param>
/// <param name="document"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="formatProvider"></param>
public static void Render(this ForEach forEach,
Document document,
OpenXmlElement parent,
ContextModel context,
OpenXmlPart documentPart,
IFormatProvider formatProvider)
{
context.ReplaceItem(forEach, formatProvider);
if (string.IsNullOrEmpty(forEach.DataSourceKey) ||
!context.ExistItem <DataSourceModel>(forEach.DataSourceKey))
{
return;
}
var datasource = context.GetItem <DataSourceModel>(forEach.DataSourceKey);
if (datasource == null || datasource.Items == null)
{
return;
}
int i = 0;
foreach (var item in datasource.Items)
{
item.AddAutoContextAddItemsPrefix(forEach, i, datasource);
for (int j = 0; j < forEach.ItemTemplate.Count; j++)
{
var template = forEach.ItemTemplate[j];
var clone = template.Clone();
// Specific rule for TemplateModels in childs :
if (clone is TemplateModel)
{
var templateElements = (clone as TemplateModel).ExtractTemplateItems(document);
foreach (var templateEement in templateElements)
{
templateEement.Render(document, parent, item, documentPart, formatProvider);
}
}
else
{
clone.Render(document, parent, item, documentPart, formatProvider);
}
}
i++;
}
}
/// <summary>
/// Render a table element
/// </summary>
/// <param name="table"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static Run Render(this BarModel barChart, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, IFormatProvider formatProvider)
{
context.ReplaceItem(barChart, formatProvider);
Run runItem = null;
if (!string.IsNullOrWhiteSpace(barChart.DataSourceKey) && context.ExistItem <BarChartModel>(barChart.DataSourceKey))
{
// We construct categories and series from the context object
var contextModel = context.GetItem <BarChartModel>(barChart.DataSourceKey);
if (contextModel.BarChartContent != null && contextModel.BarChartContent.Categories != null &&
contextModel.BarChartContent.Series != null)
{
// Update barChart object :
barChart.Categories = contextModel.BarChartContent.Categories.Select(e => new BarCategory()
{
Name = e.Name,
Color = e.Color
}).ToList();
// We update
barChart.Series = contextModel.BarChartContent.Series.Select(e => new BarSerie()
{
LabelFormatString = e.LabelFormatString,
Color = e.Color,
DataLabelColor = e.DataLabelColor,
Values = e.Values,
Name = e.Name
}).ToList();
}
else
{
return(runItem);
}
}
switch (barChart.BarChartType)
{
case BarChartType.BarChart:
runItem = CreateBarGraph(barChart, documentPart);
break;
}
if (runItem != null)
{
parent.AppendChild(runItem);
}
return(runItem);
}
/// <summary>
/// Create the image
/// </summary>
/// <param name="image">Image model</param>
/// <param name="parent">Container</param>
/// <param name="context">Context</param>
/// <param name="documentPart">MainDocumentPart</param>
/// <returns></returns>
public static OpenXmlElement Render(this Models.Image image, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart)
{
context.ReplaceItem(image);
ImagePart imagePart;
if (documentPart is MainDocumentPart)
{
imagePart = (documentPart as MainDocumentPart).AddImagePart((ImagePartType)(int)image.ImagePartType);
}
else if (documentPart is HeaderPart)
{
imagePart = (documentPart as HeaderPart).AddImagePart((ImagePartType)(int)image.ImagePartType);
}
else if (documentPart is FooterPart)
{
imagePart = (documentPart as FooterPart).AddImagePart((ImagePartType)(int)image.ImagePartType);
}
else
{
return(null);
}
bool isNotEmpty = false;
if (image.Content != null && image.Content.Length > 0)
{
using (MemoryStream stream = new MemoryStream(image.Content))
{
imagePart.FeedData(stream);
}
isNotEmpty = true;
}
else if (!string.IsNullOrWhiteSpace(image.Path))
{
using (FileStream stream = new FileStream(image.Path, FileMode.Open))
{
imagePart.FeedData(stream);
}
isNotEmpty = true;
}
if (isNotEmpty)
{
OpenXmlElement result = CreateImage(imagePart, image, documentPart);
parent.AppendChild(result);
return(result);
}
else
{
return(null);
}
}
/// <summary>
/// Render a bookmarkStart element.
/// </summary>
/// <param name="hyperlink"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static OpenXmlElement Render(this BookmarkEnd bookmarkEnd, OpenXmlElement parent, ContextModel context, IFormatProvider formatProvider)
{
context.ReplaceItem(bookmarkEnd, formatProvider);
if (bookmarkEnd.Show)
{
DocumentFormat.OpenXml.Wordprocessing.BookmarkEnd bookmarkEndElement = new DocumentFormat.OpenXml.Wordprocessing.BookmarkEnd()
{
Id = bookmarkEnd.Id
};
parent.Append(bookmarkEndElement);
return(bookmarkEndElement);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="row"></param>
/// <param name="document"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="isHeader"></param>
/// <param name="isAlternateRow">true for even lines</param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static TableRow Render(this Row row, Models.Document document, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, bool isHeader, bool isAlternateRow, IFormatProvider formatProvider)
{
if (!string.IsNullOrWhiteSpace(row.ShowKey) && context.ExistItem <BooleanModel>(row.ShowKey) && !context.GetItem <BooleanModel>(row.ShowKey).Value)
{
return(null);
}
context.ReplaceItem(row, formatProvider);
TableRow wordRow = new TableRow();
TableRowProperties wordRowProperties = new TableRowProperties();
if (isHeader)
{
wordRowProperties.AppendChild(new TableHeader()
{
Val = OnOffOnlyValues.On
});
}
wordRow.AppendChild(wordRowProperties);
if (row.RowHeight.HasValue)
{
wordRowProperties.AppendChild(new TableRowHeight()
{
Val = UInt32Value.FromUInt32((uint)row.RowHeight.Value)
});
}
if (row.CantSplit)
{
wordRowProperties.AppendChild(new CantSplit());
}
foreach (var cell in row.Cells)
{
cell.InheritFromParent(row);
wordRow.AppendChild(cell.Render(document, wordRow, context, documentPart, isAlternateRow, formatProvider));
}
return(wordRow);
}
public static TableRow Render(this Row row, Models.Document document, OpenXmlElement parent, ContextModel context, IList <ContextModel> cellsContext, Cell cellModel, OpenXmlPart documentPart, bool isHeader, bool isAlternateRow, IFormatProvider formatProvider)
{
context.ReplaceItem(row, formatProvider);
TableRow wordRow = new TableRow();
TableRowProperties wordRowProperties = new TableRowProperties();
if (isHeader)
{
wordRowProperties.AppendChild(new TableHeader()
{
Val = OnOffOnlyValues.On
});
}
wordRow.AppendChild(wordRowProperties);
if (row.RowHeight.HasValue)
{
wordRowProperties.AppendChild(new TableRowHeight()
{
Val = UInt32Value.FromUInt32((uint)row.RowHeight.Value)
});
}
if (row.CantSplit)
{
wordRowProperties.AppendChild(new CantSplit());
}
foreach (var cellContext in cellsContext)
{
var cell = cellModel.Clone();
cell.InheritFromParent(row);
wordRow.AppendChild(cell.Render(document, wordRow, cellContext, documentPart, isAlternateRow, formatProvider));
}
return(wordRow);
}
public static OpenXmlElement Render(this Paragraph paragraph, OpenXmlElement parent, ContextModel context, IFormatProvider formatProvider)
{
context.ReplaceItem(paragraph, formatProvider);
var openXmlPar = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
openXmlPar.ParagraphProperties = new DocumentFormat.OpenXml.Wordprocessing.ParagraphProperties()
{
Shading = new DocumentFormat.OpenXml.Wordprocessing.Shading()
{
Fill = paragraph.Shading
},
Justification = new DocumentFormat.OpenXml.Wordprocessing.Justification()
{
Val = paragraph.Justification.ToOOxml()
},
SpacingBetweenLines = new DocumentFormat.OpenXml.Wordprocessing.SpacingBetweenLines()
};
if (paragraph.SpacingBefore.HasValue)
{
openXmlPar.ParagraphProperties.SpacingBetweenLines.Before = paragraph.SpacingBefore.ToString();
}
if (paragraph.SpacingAfter.HasValue)
{
openXmlPar.ParagraphProperties.SpacingBetweenLines.After = paragraph.SpacingAfter.ToString();
}
if (paragraph.SpacingBetweenLines.HasValue)
{
openXmlPar.ParagraphProperties.SpacingBetweenLines.Line = paragraph.SpacingBetweenLines.ToString();
}
if (!string.IsNullOrWhiteSpace(paragraph.ParagraphStyleId))
{
openXmlPar.ParagraphProperties.ParagraphStyleId = new DocumentFormat.OpenXml.Wordprocessing.ParagraphStyleId()
{
Val = paragraph.ParagraphStyleId
}
}
;
if (paragraph.Borders != null)
{
openXmlPar.ParagraphProperties.AppendChild(paragraph.Borders.RenderParagraphBorder());
}
if (paragraph.Keeplines)
{
openXmlPar.ParagraphProperties.KeepLines = new DocumentFormat.OpenXml.Wordprocessing.KeepLines();
}
if (paragraph.KeepNext)
{
openXmlPar.ParagraphProperties.KeepNext = new DocumentFormat.OpenXml.Wordprocessing.KeepNext();
}
if (paragraph.PageBreakBefore)
{
openXmlPar.ParagraphProperties.PageBreakBefore = new DocumentFormat.OpenXml.Wordprocessing.PageBreakBefore();
}
// Indents :
if (paragraph.Indentation != null)
{
openXmlPar.ParagraphProperties.Indentation = paragraph.Indentation.ToOpenXmlElement();
}
parent.Append(openXmlPar);
return(openXmlPar);
}
/// <summary>
/// Render a table element
/// </summary>
/// <param name="uniformGrid"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <returns></returns>
public static DocumentFormat.OpenXml.Wordprocessing.Table Render(this UniformGrid uniformGrid, Document document, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, IFormatProvider formatProvider)
{
context.ReplaceItem(uniformGrid, formatProvider);
if (!string.IsNullOrEmpty(uniformGrid.DataSourceKey) && context.ExistItem <DataSourceModel>(uniformGrid.DataSourceKey))
{
var datasource = context.GetItem <DataSourceModel>(uniformGrid.DataSourceKey);
if (datasource != null && datasource.Items.Count > 0)
{
var createdTable = TableExtensions.CreateTable(document, uniformGrid, context, documentPart, formatProvider);
var wordTable = createdTable.Item1;
var tableLook = createdTable.Item2;
// Before rows :
TableExtensions.ManageBeforeAfterRows(document, uniformGrid, uniformGrid.BeforeRows, wordTable, context, documentPart, formatProvider);
// Table of cells :
List <List <ContextModel> > rowsContentContexts = new List <List <ContextModel> >();
int i = 0;
var lastCellsRow = new List <ContextModel>();
// add content rows
foreach (var item in datasource.Items)
{
if (i > 0 && i % uniformGrid.ColsWidth.Length == 0)
{
// end of line :
rowsContentContexts.Add(lastCellsRow);
lastCellsRow = new List <ContextModel>();
}
lastCellsRow.Add(item);
i++;
}
if (i % uniformGrid.ColsWidth.Length == 0)
{
rowsContentContexts.Add(lastCellsRow);
}
if (datasource.Items.Count % uniformGrid.ColsWidth.Length > 0)
{
var acountAddNullItems = uniformGrid.ColsWidth.Length - (datasource.Items.Count % uniformGrid.ColsWidth.Length);
if (acountAddNullItems > 0)
{
for (int j = 0; j < acountAddNullItems; j++)
{
lastCellsRow.Add(new ContextModel());
}
rowsContentContexts.Add(lastCellsRow);
}
}
// Now we create all row :
i = 0;
foreach (var rowContentContext in rowsContentContexts)
{
var row = new Row
{
CantSplit = uniformGrid.CantSplitRows,
};
row.InheritFromParent(uniformGrid);
wordTable.AppendChild(row.Render(document, wordTable, context, rowContentContext, uniformGrid.CellModel, documentPart, false, (i % 2 == 1), formatProvider));
i++;
}
// After rows :
TableExtensions.ManageBeforeAfterRows(document, uniformGrid, uniformGrid.AfterRows, wordTable, context, documentPart, formatProvider);
TableExtensions.ManageFooterRow(document, uniformGrid, wordTable, tableLook, context, documentPart, formatProvider);
parent.AppendChild(wordTable);
return(wordTable);
}
}
return(null);
}
/// <summary>
/// Render a cell in a word document
/// </summary>
/// <param name="cell"></param>
/// <param name="document"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="documentPart"></param>
/// <param name="isInAlternateRow"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static TableCell Render(this Cell cell,
Models.Document document,
OpenXmlElement parent,
ContextModel context,
OpenXmlPart documentPart,
bool isInAlternateRow,
IFormatProvider formatProvider)
{
context.ReplaceItem(cell, formatProvider);
TableCell wordCell = new TableCell();
TableCellProperties cellProp = new TableCellProperties();
wordCell.AppendChild(cellProp);
if (isInAlternateRow)
{
cell.ReplaceAlternateConfiguration();
}
cellProp.AddBorders(cell);
cellProp.AddShading(cell);
cellProp.AddMargin(cell);
cellProp.AddJustifications(cell);
if (cell.CellWidth != null)
{
cellProp.AppendChild(new TableCellWidth()
{
Width = cell.CellWidth.Width, Type = cell.CellWidth.Type.ToOOxml()
});
}
// manage cell column and row span
if (cell.ColSpan > 1)
{
cellProp.AppendChild(new GridSpan()
{
Val = cell.ColSpan
});
}
if (cell.Fusion)
{
if (cell.FusionChild)
{
cellProp.AppendChild(new VerticalMerge()
{
Val = MergedCellValues.Continue
});
}
else
{
cellProp.AppendChild(new VerticalMerge()
{
Val = MergedCellValues.Restart
});
}
}
if (!cell.Show)
{
return(wordCell);
}
if (cell.ChildElements.Any(x => x is Models.TemplateModel))
{
// Need to replace elements :
for (int i = 0; i < cell.ChildElements.Count; i++)
{
var e = cell.ChildElements[i];
if (e is TemplateModel)
{
var elements = (e as TemplateModel).ExtractTemplateItems(document);
if (i == cell.ChildElements.Count - 1)
{
cell.ChildElements.AddRange(elements);
}
else
{
cell.ChildElements.InsertRange(i + 1, elements);
}
}
}
}
if (cell.ChildElements.Any(x => x is Models.Paragraph) || cell.ChildElements.Any(x => x is ForEach))
{
foreach (var element in cell.ChildElements)
{
element.InheritFromParent(cell);
if (element is Models.Paragraph ||
element is ForEach)
{
element.Render(document, wordCell, context, documentPart, formatProvider);
}
else
{
var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
if (cell.Justification.HasValue)
{
var ppr = new ParagraphProperties();
ppr.AppendChild(new Justification()
{
Val = cell.Justification.Value.ToOOxml()
});
paragraph.AppendChild(ppr);
}
wordCell.AppendChild(paragraph);
var r = new Run();
paragraph.AppendChild(r);
element.Render(document, r, context, documentPart, formatProvider);
}
}
}
else
{
// fill cell content (need at least an empty paragraph)
var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
if (cell.Justification.HasValue)
{
var ppr = new ParagraphProperties();
ppr.AppendChild(new Justification()
{
Val = cell.Justification.Value.ToOOxml()
});
paragraph.AppendChild(ppr);
}
wordCell.AppendChild(paragraph);
var r = new Run();
paragraph.AppendChild(r);
foreach (var element in cell.ChildElements)
{
element.InheritFromParent(cell);
element.Render(document, r, context, documentPart, formatProvider);
}
}
return(wordCell);
}
/// <summary>
/// Render a table element
/// </summary>
/// <param name="table"></param>
/// <param name="parent"></param>
/// <param name="context"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public static Table Render(this Models.Table table, Models.Document document, OpenXmlElement parent, ContextModel context, OpenXmlPart documentPart, IFormatProvider formatProvider)
{
context.ReplaceItem(table, formatProvider);
var createdTable = CreateTable(document, table, context, documentPart, formatProvider);
var wordTable = createdTable.Item1;
var tableLook = createdTable.Item2;
// Before rows :
ManageBeforeAfterRows(document, table, table.BeforeRows, wordTable, context, documentPart, formatProvider);
// add content rows
if (!string.IsNullOrEmpty(table.DataSourceKey))
{
if (context.ExistItem <DataSourceModel>(table.DataSourceKey))
{
var datasource = context.GetItem <DataSourceModel>(table.DataSourceKey);
int i = 0;
foreach (var item in datasource.Items)
{
var row = table.RowModel.Clone();
row.InheritFromParent(table);
if (!string.IsNullOrWhiteSpace(table.AutoContextAddItemsPrefix))
{
// We add automatic keys :
// Is first item
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IsFirstItem#", new BooleanModel(i == 0));
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IsNotFirstItem#", new BooleanModel(i > 0));
// Is last item
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IsLastItem#", new BooleanModel(i == datasource.Items.Count - 1));
// Index of the element (Based on 0, and based on 1)
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IndexBaseZero#", new StringModel(i.ToString()));
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IndexBaseOne#", new StringModel((i + 1).ToString()));
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IsOdd#", new BooleanModel(i % 2 == 1));
item.AddItem("#" + table.AutoContextAddItemsPrefix + "_TableRow_IsEven#", new BooleanModel(i % 2 == 0));
}
wordTable.AppendChild(row.Render(document, wordTable, item, documentPart, false, (i % 2 == 1), formatProvider));
i++;
}
}
}
else
{
int i = 0;
foreach (var row in table.Rows)
{
row.InheritFromParent(table);
wordTable.AppendChild(row.Render(document, wordTable, context, documentPart, false, (i % 2 == 1), formatProvider));
i++;
}
}
// After rows :
ManageBeforeAfterRows(document, table, table.AfterRows, wordTable, context, documentPart, formatProvider);
// Footer
ManageFooterRow(document, table, wordTable, tableLook, context, documentPart, formatProvider);
parent.AppendChild(wordTable);
return(wordTable);
}
