public override void Render(ReportPageEventArgs rpea)
{
if (rpea == null)
{
throw new ArgumentNullException("rpea");
}
base.Render(rpea);
Rectangle rectangle = base.DisplayRectangle;
StandardPrinter.FillBackground(rpea.PrintPageEventArgs.Graphics, this.BaseStyleDecorator);
BaseLine line = new BaseLine(base.ForeColor, base.DashStyle, base.Thickness, LineCap.Round, LineCap.Round, DashCap.Round);
using (Pen pen = line.CreatePen(line.Thickness)){
if (pen != null)
{
shape.CornerRadius = this.CornerRadius;
GraphicsPath gfxPath = shape.CreatePath(rectangle);
rpea.PrintPageEventArgs.Graphics.FillPath(new SolidBrush(BackColor), gfxPath);;
rpea.PrintPageEventArgs.Graphics.DrawPath(pen, gfxPath);
}
}
}
public static ExportContainer ConvertToContainer(ISimpleContainer container, Point offset)
{
if (container == null)
{
throw new ArgumentNullException("item");
}
PrintHelper.AdjustParent(container, container.Items);
IExportColumnBuilder lineBuilder = container as IExportColumnBuilder;
if (lineBuilder != null)
{
ExportContainer lineItem = (ExportContainer)lineBuilder.CreateExportColumn();
lineItem.StyleDecorator.Location = new Point(offset.X + lineItem.StyleDecorator.Location.X,
offset.Y);
lineItem.StyleDecorator.DisplayRectangle = new Rectangle(lineItem.StyleDecorator.Location,
lineItem.StyleDecorator.Size);
StandardPrinter.AdjustBackColor(container);
return(lineItem);
}
return(null);
}
public void ExpectPrintLineNotToThrow()
{
var printer = new StandardPrinter();
var message = "testMessage";
Assert.DoesNotThrow(() => printer.PrintLine(message));
}
private void Init()
{
this.reportDocument.DocumentName = reportSettings.ReportName;
// Events from ReportDocument
this.reportDocument.QueryPageSettings += new QueryPageSettingsEventHandler(ReportQueryPage);
this.reportDocument.BeginPrint += new PrintEventHandler(ReportBegin);
this.reportDocument.PrintPage += delegate(object sender, PrintPageEventArgs e){
this.CalculatePageBounds();
};
this.reportDocument.EndPrint += new PrintEventHandler(ReportEnd);
// homemade events
this.reportDocument.BodyStart += new EventHandler <ReportPageEventArgs> (BodyStart);
this.reportDocument.BodyEnd += new EventHandler <ReportPageEventArgs> (BodyEnd);
//
this.reportDocument.RenderReportHeader += new EventHandler <ReportPageEventArgs> (PrintReportHeader);
this.reportDocument.RenderPageHeader += new EventHandler <ReportPageEventArgs> (PrintPageHeader);
this.reportDocument.RenderDetails += new EventHandler <ReportPageEventArgs> (PrintDetail);
this.reportDocument.RenderPageEnd += new EventHandler <ReportPageEventArgs> (PrintPageFooter);
this.reportDocument.RenderReportEnd += new EventHandler <ReportPageEventArgs> (PrintReportFooter);
this.Evaluator = StandardPrinter.SetupEvaluator();
}
private Point ConvertGroupHeader(ExporterCollection exportList, BaseSection section, Point offset)
{
var retVal = Point.Empty;
var rowSize = Size.Empty;
ReportItemCollection groupCollection = null;
var groupedRow = new Collection <GroupHeader>(table.Items.OfType <GroupHeader>().ToList());
if (groupedRow.Count == 0)
{
groupCollection = section.Items.ExtractGroupedColumns();
base.DataNavigator.Fill(groupCollection);
base.FireSectionRendering(section);
ExporterCollection list = StandardPrinter.ConvertPlainCollection(groupCollection, offset);
StandardPrinter.EvaluateRow(base.Evaluator, list);
exportList.AddRange(list);
AfterConverting(list);
retVal = new Point(base.DefaultLeftPosition, offset.Y + groupCollection[0].Size.Height + 20 + (3 * GlobalValues.GapBetweenContainer));
}
else
{
rowSize = groupedRow[0].Size;
FillRow(groupedRow[0], base.DataNavigator);
base.FireGroupHeaderRendering(groupedRow[0]);
retVal = ConvertStandardRow(exportList, groupedRow[0]);
groupedRow[0].Size = rowSize;
}
return(retVal);
}
private Point RenderSectionWithSimpleContainer(BaseSection section,
ISimpleContainer container,
Point offset,
ReportPageEventArgs rpea)
{
Point currentPosition = new Point(section.Location.X + container.Location.X, offset.Y);
// if (section.VisibleInReport)
// {
//Always set section.size to it's original value
section.Size = this.SectionBounds.DetailSectionRectangle.Size;
Size containerSize = new Size(section.Items[0].Size.Width, section.Items[0].Size.Height);
LayoutHelper.SetLayoutForRow(rpea.PrintPageEventArgs.Graphics, base.Layout, container);
section.Render(rpea);
PrintHelper.AdjustParent(section, section.Items);
foreach (BaseReportItem item in section.Items)
{
ISimpleContainer con = item as ISimpleContainer;
if (con != null)
{
Rectangle r = StandardPrinter.RenderContainer(container, Evaluator, offset, rpea);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
}
else
{
item.SectionOffset = section.SectionOffset;
Point saveLocation = item.Location;
item.Render(rpea);
item.Location = saveLocation;
ISimpleContainer cont = item as ISimpleContainer;
Rectangle r = StandardPrinter.RenderContainer(cont, Evaluator, currentPosition, rpea);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
item.Location = saveLocation;
rpea.LocationAfterDraw = new Point(rpea.LocationAfterDraw.X, section.SectionOffset + section.Size.Height);
}
section.Items[0].Size = containerSize;
return(currentPosition);
}
return(currentPosition);
// }
// return currentPosition;
}
public void ExpectPrintMatrixNotToThrow()
{
var matrix = new MatrixFactory().CreateMatrix(MatrixTypes.BIG);
var player = new Player();
var printer = new StandardPrinter();
Assert.DoesNotThrow(() => printer.PrintMatrix(matrix, player));
}
public void ExpectPrintLineOfPrinterDecoratorNotToThrow()
{
var lightPrinter = new PrinterLightMode();
var standartPrinter = new StandardPrinter();
lightPrinter.SetPrinter(standartPrinter);
var message = "test message";
Assert.DoesNotThrow(() => lightPrinter.PrintLine(message));
}
/// <summary>
/// Fill the Background and draw a (Rectangle)Frame around the Control
/// </summary>
/// <param name="graphics"></param>
protected virtual void Decorate(Graphics graphics)
{
if (graphics == null)
{
throw new ArgumentNullException("graphics");
}
RectangleShape shape = new RectangleShape();
this.FillShape(graphics, shape);
StandardPrinter.DrawBorder(graphics, this.StyleDecorator as BaseStyleDecorator);
}
public void ExpectGetPrintFrameOfPrintDecoratorNotToBeEmptyString()
{
var matrix = new MatrixFactory().CreateMatrix(MatrixTypes.BIG);
var player = new Player();
var printer = new PrinterLightMode();
var standartPrinter = new StandardPrinter();
printer.SetPrinter(standartPrinter);
var result = printer.GetPrintFrame(matrix, player);
Assert.AreNotEqual(result.Length, 0);
}
public void ExpectGetPrintFrameToReturntNotEmptyString()
{
var director = new MatrixDirector();
var builder = new SmallMatrixBuilder();
director.Construct(builder);
var matrix = builder.GetMatrix();
var player = new Player();
var printer = new StandardPrinter();
var result = printer.GetPrintFrame(matrix, player);
Assert.AreNotEqual(result.Length, 0);
}
protected static ExporterCollection ConvertItems(ISimpleContainer row, Point offset)
{
IExportColumnBuilder exportLineBuilder = row as IExportColumnBuilder;
if (exportLineBuilder != null)
{
ExportContainer lineItem = StandardPrinter.ConvertToContainer(row, offset);
StandardPrinter.AdjustBackColor(row);
ExporterCollection list = StandardPrinter.ConvertPlainCollection(row.Items, offset);
lineItem.Items.AddRange(list);
ExporterCollection containerList = new ExporterCollection();
containerList.Add(lineItem);
return(containerList);
}
return(null);
}
public override void Render(ReportPageEventArgs rpea)
{
if (rpea == null)
{
throw new ArgumentNullException("rpea");
}
base.Render(rpea);
StandardPrinter.FillBackground(rpea.PrintPageEventArgs.Graphics, this.BaseStyleDecorator);
StandardPrinter.DrawBorder(rpea.PrintPageEventArgs.Graphics, this.BaseStyleDecorator);
string formated = StandardFormatter.FormatOutput(this.text, this.FormatString, this.DataType, String.Empty);
Print(rpea, formated, base.DisplayRectangle);
base.NotifyAfterPrint(rpea.LocationAfterDraw);
}
protected ExporterCollection ConvertSection(BaseSection section, int dataRow)
{
FireSectionRenderEvent(section, dataRow);
PrintHelper.AdjustParent((BaseSection)section, section.Items);
ExporterCollection list = new ExporterCollection();
if (section.Items.Count > 0)
{
Point offset = new Point(section.Location.X, section.SectionOffset);
// Call layouter only once per section
Rectangle desiredRectangle = Layouter.Layout(this.Graphics, section);
Rectangle sectionRectangle = new Rectangle(section.Location, section.Size);
if (!sectionRectangle.Contains(desiredRectangle))
{
section.Size = new Size(section.Size.Width, desiredRectangle.Size.Height + GlobalValues.ControlMargins.Top + GlobalValues.ControlMargins.Bottom);
}
foreach (BaseReportItem item in section.Items)
{
ISimpleContainer container = item as ISimpleContainer;
if (container != null)
{
ExportContainer exportContainer = StandardPrinter.ConvertToContainer(container, offset);
StandardPrinter.AdjustBackColor(container);
ExporterCollection clist = StandardPrinter.ConvertPlainCollection(container.Items, offset);
exportContainer.Items.AddRange(clist);
list.Add(exportContainer);
}
else
{
list = StandardPrinter.ConvertPlainCollection(section.Items, offset);
}
}
}
return(list);
}
public override void Render(ReportPageEventArgs rpea)
{
if (rpea == null)
{
throw new ArgumentNullException("rpea");
}
Point point = this.Location;
base.Render(rpea);
StandardPrinter.AdjustBackColor(this);
StandardPrinter.FillBackground(rpea.PrintPageEventArgs.Graphics, this.BaseStyleDecorator);
StandardPrinter.DrawBorder(rpea.PrintPageEventArgs.Graphics, this.BaseStyleDecorator);
rpea.LocationAfterDraw = new Point(rpea.LocationAfterDraw.X, this.Location.Y + this.Size.Height);
this.Location = point;
base.NotifyAfterPrint(rpea.LocationAfterDraw);
}
protected virtual Point RenderSection(ReportPageEventArgs rpea)
{
Point currentPosition = Point.Empty;
this.CurrentSection.Render(rpea);
Evaluator.SinglePage = this.reportDocument.SinglePage;
if (this.CurrentSection.Items.Count > 0)
{
Rectangle desiredRectangle = Layout.Layout(rpea.PrintPageEventArgs.Graphics, this.CurrentSection);
Rectangle sectionRectangle = new Rectangle(this.CurrentSection.Location.X,
this.CurrentSection.Location.Y,
this.CurrentSection.Size.Width,
this.CurrentSection.Size.Height);
if (desiredRectangle.Height >= sectionRectangle.Height)
{
this.CurrentSection.Size = new Size(this.CurrentSection.Size.Width, desiredRectangle.Height + 10);
}
if (this.CurrentSection.DrawBorder)
{
StandardPrinter.DrawBorder(rpea.PrintPageEventArgs.Graphics, this.CurrentSection.BaseStyleDecorator);
}
// PrintHelper.DebugRectangle(rpea.PrintPageEventArgs.Graphics,Pens.Blue,new Rectangle(CurrentSection.Location,CurrentSection.Size));
}
Rectangle r = StandardPrinter.RenderPlainCollection(this.CurrentSection,
this.CurrentSection.Items,
Evaluator,
new Point(this.CurrentSection.Location.X, this.CurrentSection.SectionOffset),
rpea);
return(PrintHelper.ConvertRectangleToCurentPosition(r));
}
public BaseConverter(IDataNavigator dataNavigator, ExporterPage singlePage,
ILayouter layouter)
{
if (dataNavigator == null)
{
throw new ArgumentNullException("dataNavigator");
}
if (singlePage == null)
{
throw new ArgumentNullException("singlePage");
}
if (layouter == null)
{
throw new ArgumentNullException("layouter");
}
this.SinglePage = singlePage;
this.DataNavigator = dataNavigator;
SectionBounds = this.SinglePage.SectionBounds;
this.Layouter = layouter;
this.Evaluator = StandardPrinter.CreateEvaluator(this.SinglePage, this.DataNavigator);
}
private ExporterCollection ConvertDataRow(ISimpleContainer simpleContainer)
{
ExporterCollection exporterCollection = new ExporterCollection();
base.CurrentPosition = base.SectionBounds.Offset;
var p = base.CurrentPosition;
BaseSection section = parent as BaseSection;
DefaultLeftPosition = parent.Location.X;
Size groupSize = Size.Empty;
Size childSize = Size.Empty;
if (section.Items.FindGroupHeader().Count > 0)
{
groupSize = section.Items[0].Size;
childSize = section.Items[1].Size;
}
do
{
base.SaveSectionSize(section.Size);
PrintHelper.AdjustSectionLocation(section);
section.Size = this.SectionBounds.DetailSectionRectangle.Size;
// did we have GroupedItems at all
if (section.Items.FindGroupHeader().Count > 0)
{
// GetType child navigator
IDataNavigator childNavigator = base.DataNavigator.GetChildNavigator;
base.Evaluator.SinglePage.IDataNavigator = childNavigator;
base.CurrentPosition = ConvertGroupHeader(exporterCollection, section, base.CurrentPosition);
section.Size = base.RestoreSectionSize;
section.Items[0].Size = groupSize;
section.Items[1].Size = childSize;
childNavigator.Reset();
childNavigator.MoveNext();
//Convert children
if (childNavigator != null)
{
StandardPrinter.AdjustBackColor(simpleContainer);
do
{
section.Size = base.RestoreSectionSize;
section.Items[0].Size = groupSize;
section.Items[1].Size = childSize;
FillRow(simpleContainer, childNavigator);
FireRowRendering(simpleContainer, childNavigator);
PrepareContainerForConverting(section, simpleContainer);
base.CurrentPosition = ConvertStandardRow(exporterCollection, simpleContainer);
CheckForPageBreak(section, exporterCollection);
}while (childNavigator.MoveNext());
// GroupFooter
base.ConvertGroupFooter(section, exporterCollection);
base.PageBreakAfterGroupChange(section, exporterCollection);
base.Evaluator.SinglePage.IDataNavigator = base.DataNavigator;
}
}
else
{
// No Grouping at all, the first item in section.items is the DetailRow
Size containerSize = section.Items[0].Size;
FillRow(simpleContainer, base.DataNavigator);
FireRowRendering(simpleContainer, base.DataNavigator);
Console.WriteLine("ConvertDazaRow");
base.PrepareContainerForConverting(section, simpleContainer);
base.CurrentPosition = ConvertStandardRow(exporterCollection, simpleContainer);
section.Size = base.RestoreSectionSize;
section.Items[0].Size = containerSize;
}
CheckForPageBreak(section, exporterCollection);
ShouldDrawBorder(section, exporterCollection);
}while (base.DataNavigator.MoveNext());
SectionBounds.ReportFooterRectangle = new Rectangle(SectionBounds.ReportFooterRectangle.Left,
section.Location.Y + section.Size.Height,
SectionBounds.ReportFooterRectangle.Width,
SectionBounds.ReportFooterRectangle.Height);
return(exporterCollection);
}
protected void AfterConverting(ExporterCollection convertedList)
{
StandardPrinter.EvaluateRow(Evaluator, convertedList);
}
protected void RenderTable(BaseReportItem parent, ITableContainer tableContainer, ReportPageEventArgs rpea)
{
if (rpea == null)
{
throw new ArgumentNullException("rpea");
}
Point saveLocation = tableContainer.Location;
Point currentPosition = new Point(PrintHelper.DrawingAreaRelativeToParent(this.CurrentSection, tableContainer).Location.X,
this.CurrentSection.Location.Y);
tableContainer.Items.SortByLocation();
Size rs = Size.Empty;
foreach (BaseRowItem row in tableContainer.Items)
{
if (row != null)
{
rs = row.Size;
PrintHelper.AdjustParent(tableContainer, tableContainer.Items);
if (PrintHelper.IsTextOnlyRow(row))
{
LayoutHelper.SetLayoutForRow(rpea.PrintPageEventArgs.Graphics, base.Layout, row);
Rectangle r = StandardPrinter.RenderContainer(row, Evaluator, currentPosition, rpea);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
tableContainer.Location = saveLocation;
}
else
{
int adjust = row.Location.Y - saveLocation.Y;
row.Location = new Point(row.Location.X, row.Location.Y - adjust - 3 * GlobalValues.GapBetweenContainer);
rs = row.Size;
do
{
if (PrintHelper.IsPageFull(new Rectangle(currentPosition, row.Size), this.SectionBounds))
{
tableContainer.Location = saveLocation;
AbstractRenderer.PageBreak(rpea);
return;
}
this.dataNavigator.Fill(row.Items);
LayoutHelper.SetLayoutForRow(rpea.PrintPageEventArgs.Graphics, base.Layout, row);
Rectangle r = StandardPrinter.RenderContainer(row, Evaluator, currentPosition, rpea);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
row.Size = rs;
}while (this.dataNavigator.MoveNext());
}
}
row.Size = rs;
}
// base.NotifyAfterPrint (rpea.LocationAfterDraw);
}
public void Render(ISimpleContainer table, ReportPageEventArgs rpea, IExpressionEvaluatorFacade evaluator)
{
if (this.dataNavigator.CurrentRow < 0)
{
this.dataNavigator.MoveNext();
}
this.reportPageEventArgs = rpea;
Point saveLocation = table.Location;
Rectangle pageBreakRect = Rectangle.Empty;
Point currentPosition = new Point(PrintHelper.DrawingAreaRelativeToParent(this.currentSection, table).Location.X,
this.currentSection.Location.Y);
table.Items.SortByLocation();
Size rs = Size.Empty;
ISimpleContainer headerRow = null;
var simpleContainer = table.Items[0] as ISimpleContainer;
// foreach (BaseRowItem row in table.Items)
// {
rs = simpleContainer.Size;
PrintHelper.AdjustParent(table as BaseReportItem, table.Items);
// if (PrintHelper.IsTextOnlyRow(simpleContainer) )
// {
PrintHelper.SetLayoutForRow(ReportPageEventArgs.PrintPageEventArgs.Graphics, Layouter, simpleContainer);
var r = StandardPrinter.RenderContainer(simpleContainer, evaluator, currentPosition, ReportPageEventArgs);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
table.Location = saveLocation;
// }
// else {
//---------------
simpleContainer = table.Items[1] as ISimpleContainer;
int adjust = simpleContainer.Location.Y - saveLocation.Y;
simpleContainer.Location = new Point(simpleContainer.Location.X, simpleContainer.Location.Y - adjust - 3 * GlobalValues.GapBetweenContainer);
rs = simpleContainer.Size;
do
{
pageBreakRect = PrintHelper.CalculatePageBreakRectangle((BaseReportItem)table, currentPosition);
if (PrintHelper.IsPageFull(pageBreakRect, this.SectionBounds))
{
Console.WriteLine("PageBreak - PageFull");
table.Location = saveLocation;
AbstractRenderer.PageBreak(ReportPageEventArgs);
return;
}
this.dataNavigator.Fill(simpleContainer.Items);
PrintHelper.SetLayoutForRow(ReportPageEventArgs.PrintPageEventArgs.Graphics, Layouter, simpleContainer);
r = StandardPrinter.RenderContainer(simpleContainer, evaluator, currentPosition, ReportPageEventArgs);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
simpleContainer.Size = rs;
}while (this.dataNavigator.MoveNext());
//-----
// }
}
public void old_Render(ISimpleContainer table, ReportPageEventArgs rpea, IExpressionEvaluatorFacade evaluator)
{
if (this.dataNavigator.CurrentRow < 0)
{
this.dataNavigator.MoveNext();
}
this.reportPageEventArgs = rpea;
Point saveLocation = table.Location;
Rectangle pageBreakRect = Rectangle.Empty;
Point currentPosition = new Point(PrintHelper.DrawingAreaRelativeToParent(this.currentSection, table).Location.X,
this.currentSection.Location.Y);
table.Items.SortByLocation();
Size rs = Size.Empty;
foreach (BaseRowItem row in table.Items)
{
rs = row.Size;
PrintHelper.AdjustParent(table as BaseReportItem, table.Items);
if (PrintHelper.IsTextOnlyRow(row))
{
PrintHelper.SetLayoutForRow(ReportPageEventArgs.PrintPageEventArgs.Graphics, Layouter, row);
Rectangle r = StandardPrinter.RenderContainer(row, evaluator, currentPosition, ReportPageEventArgs);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
table.Location = saveLocation;
}
else
{
int adjust = row.Location.Y - saveLocation.Y;
row.Location = new Point(row.Location.X, row.Location.Y - adjust - 3 * GlobalValues.GapBetweenContainer);
rs = row.Size;
do
{
pageBreakRect = PrintHelper.CalculatePageBreakRectangle((BaseReportItem)table, currentPosition);
if (PrintHelper.IsPageFull(parentRectangle, this.SectionBounds))
{
Console.WriteLine("PageBreak - PageFull");
table.Location = saveLocation;
AbstractRenderer.PageBreak(ReportPageEventArgs);
return;
}
this.dataNavigator.Fill(row.Items);
PrintHelper.SetLayoutForRow(ReportPageEventArgs.PrintPageEventArgs.Graphics, Layouter, row);
Rectangle r = StandardPrinter.RenderContainer(row, evaluator, currentPosition, ReportPageEventArgs);
currentPosition = PrintHelper.ConvertRectangleToCurentPosition(r);
row.Size = rs;
}while (this.dataNavigator.MoveNext());
}
row.Size = rs;
}
// base.NotifyAfterPrint (rpea.LocationAfterDraw);
}
private ExporterCollection ConvertInternal(ExporterCollection exporterCollection)
{
BaseSection section = table.Parent as BaseSection;
ISimpleContainer headerRow = null;
Point dataAreaStart = new Point(table.Items[0].Location.X, table.Items[0].Location.Y + base.CurrentPosition.Y);
base.CurrentPosition = new Point(PrintHelper.DrawingAreaRelativeToParent(this.table.Parent, this.table).Location.X,
base.SectionBounds.DetailArea.Top);
base.DefaultLeftPosition = base.CurrentPosition.X;
this.table.Items.SortByLocation();
// Header
var simpleContainer = table.Items[0] as ISimpleContainer;
Size containerSize = Size.Empty;
if (simpleContainer.Items.Count > 0)
{
simpleContainer.Location = new Point(simpleContainer.Location.X, simpleContainer.Location.Y);
simpleContainer.Parent = (BaseReportItem)this.table;
base.SaveSectionSize(section.Size);
containerSize = simpleContainer.Size;
if (PrintHelper.IsTextOnlyRow(simpleContainer))
{
headerRow = simpleContainer;
base.PrepareContainerForConverting(section, headerRow);
base.CurrentPosition = ConvertContainer(exporterCollection, headerRow, base.DefaultLeftPosition, base.CurrentPosition);
}
GroupHeader row = table.Items[1] as GroupHeader;
if (row != null)
{
//grouped
do
{
// GetType child navigator
IDataNavigator childNavigator = base.DataNavigator.GetChildNavigator;
base.Evaluator.SinglePage.IDataNavigator = childNavigator;
// Convert Grouping Header
base.CurrentPosition = ConvertGroupHeader(exporterCollection, section, base.CurrentPosition);
childNavigator.Reset();
childNavigator.MoveNext();
//Convert children
if (childNavigator != null)
{
do
{
StandardPrinter.AdjustBackColor(simpleContainer);
simpleContainer = table.Items[2] as ISimpleContainer;
containerSize = simpleContainer.Size;
FillRow(simpleContainer, childNavigator);
FireRowRendering(simpleContainer, childNavigator);
PrepareContainerForConverting(section, simpleContainer);
base.CurrentPosition = ConvertStandardRow(exporterCollection, simpleContainer);
simpleContainer.Size = containerSize;
CheckForPageBreak(section, simpleContainer, headerRow, exporterCollection);
}while (childNavigator.MoveNext());
// GroupFooter
base.ConvertGroupFooter(table, exporterCollection);
base.PageBreakAfterGroupChange(section, exporterCollection);
base.Evaluator.SinglePage.IDataNavigator = base.DataNavigator;
}
}while (base.DataNavigator.MoveNext());
}
else
{
// No Grouping at all
simpleContainer = table.Items[1] as ISimpleContainer;
base.SaveSectionSize(section.Size);
containerSize = simpleContainer.Size;
do
{
PrintHelper.AdjustSectionLocation(section);
CheckForPageBreak(section, simpleContainer, headerRow, exporterCollection);
FillRow(simpleContainer, base.DataNavigator);
FireRowRendering(simpleContainer, base.DataNavigator);
base.PrepareContainerForConverting(section, simpleContainer);
base.CurrentPosition = ConvertStandardRow(exporterCollection, simpleContainer);
simpleContainer.Size = containerSize;
section.Size = base.RestoreSectionSize;
}while (base.DataNavigator.MoveNext());
base.DataNavigator.Reset();
base.DataNavigator.MoveNext();
SectionBounds.ReportFooterRectangle = new Rectangle(SectionBounds.ReportFooterRectangle.Left,
base.CurrentPosition.Y,
SectionBounds.ReportFooterRectangle.Width,
SectionBounds.ReportFooterRectangle.Height);
}
}
return(exporterCollection);
}
protected void FillBackground(Graphics graphics)
{
StandardPrinter.FillBackground(graphics, this.BaseStyleDecorator);
}
