internal void Run(IPresent ip, Row row)
{
foreach (TableRow t in _Items)
{
t.Run(ip, row);
}
return;
}
internal void Run(IPresent ip, Row row)
{
foreach (TableCell tc in _Items)
{
tc.Run(ip, row);
}
return ;
}
public string CraftPresent(string presentName)
{
ICollection <IDwarf> suitableDwarves = this.dwarfRepository.Models.Where(x => x.Energy >= 50).OrderByDescending(x => x.Energy).ToList();
if (!suitableDwarves.Any())
{
throw new InvalidOperationException(ExceptionMessages.DwarfsNotReady);
}
IPresent present = this.presentRepository.FindByName(presentName);
while (suitableDwarves.Any())
{
IDwarf dwarf = suitableDwarves.First();
this.workshop.Craft(present, dwarf);
if (dwarf.Energy <= 0)
{
this.dwarfRepository.Remove(dwarf);
suitableDwarves.Remove(dwarf);
}
if (!dwarf.Instruments.Any())
{
suitableDwarves.Remove(dwarf);
}
if (present.IsDone())
{
count++;
return(string.Format(OutputMessages.PresentIsDone, presentName));
}
}
return(string.Format(OutputMessages.PresentIsNotDone, presentName));
}
public string CraftPresent(string presentName)
{
IPresent present = this.presents.Models.FirstOrDefault(p => p.Name == presentName);
ICollection <IDwarf> suitableDwarves = this.dwarfs.Models.Where(d => d.Energy >= 50).OrderByDescending(d => d.Energy).ToList();
if (suitableDwarves.Count == 0)
{
throw new InvalidOperationException(ExceptionMessages.DwarfsNotReady);
}
Workshop workshop = new Workshop();
while (suitableDwarves.Any())
{
IDwarf currentDwarf = suitableDwarves.First();
workshop.Craft(present, currentDwarf);
if (currentDwarf.Instruments.Count == 0)
{
suitableDwarves.Remove(currentDwarf);
}
if (currentDwarf.Energy == 0)
{
suitableDwarves.Remove(currentDwarf);
this.dwarfs.Remove(currentDwarf);
}
if (present.IsDone())
{
break;
}
}
if (present.IsDone())
{
craftedPresentsCount++;
return(String.Format(OutputMessages.PresentIsDone, presentName));
}
return(String.Format(OutputMessages.PresentIsNotDone, presentName));
}
public void Craft(IPresent present, IDwarf dwarf)
{
while (dwarf.Energy > 0 && dwarf.Instruments.Any())
{
IInstrument currentInstrument = dwarf.Instruments.First();
while (!present.IsDone() && dwarf.Energy > 0 && !currentInstrument.IsBroken())
{
present.GetCrafted();
dwarf.Work();
currentInstrument.Use();
}
if (currentInstrument.IsBroken())
{
dwarf.Instruments.Remove(currentInstrument);
}
if (present.IsDone())
{
break;
}
}
}
public void Craft(IPresent present, IDwarf dwarf)
{
foreach (var instrument in dwarf.Instruments)
{
while (!instrument.IsBroken())
{
if (dwarf.Energy == 0)
{
break;
}
present.GetCrafted();
dwarf.Work();
instrument.Use();
if (present.IsDone())
{
break;
}
}
if (present.IsDone())
{
break;
}
}
}
override internal void Run(IPresent ip, Row row)
{
Report rpt = ip.Report();
_ChartMatrix.RunReset(rpt);
Rows _Data = GetFilteredData(ip.Report(), row);
SetMyData(ip.Report(), _Data);
if (!AnyRows(ip, _Data)) // if no rows, return
{
return;
}
// Build the Chart bitmap, along with data regions
ChartBase cb = null;
try
{
cb = RunChartBuild(rpt, row);
ip.Chart(this, row, cb);
}
catch (Exception ex)
{
rpt.rl.LogError(8, string.Format("Exception in Chart handling.\n{0}\n{1}", ex.Message, ex.StackTrace));
}
finally
{
if (cb != null)
{
cb.Dispose();
}
}
return;
}
override internal void Run(IPresent ip, Row row)
{
Report r = ip.Report();
WorkClass wc = GetValue(r);
wc.Data = GetFilteredData(r, row);
if (!AnyRows(ip, wc.Data)) // if no rows return
{
return; // nothing left to do
}
RunSetGrouping(r, wc);
base.Run(ip, row);
if (!ip.ListStart(this, row))
{
return; // renderer doesn't want to continue
}
RunGroups(ip, wc, wc.Groups);
ip.ListEnd(this, row);
RemoveValue(r);
}
override public void Run(IPresent ip, Row row)
{
Report rpt = ip.Report();
_ChartMatrix.RunReset(rpt);
Rows _Data = GetFilteredData(ip.Report(), row);
SetMyData(ip.Report(), _Data);
if (!AnyRows(ip, _Data)) // if no rows, return
return;
// Build the Chart bitmap, along with data regions
ChartBase cb=null;
try
{
cb = RunChartBuild(rpt, row);
ip.Chart(this, row, cb);
}
catch (Exception ex)
{
rpt.rl.LogError(8, string.Format("Exception in Chart handling.\n{0}\n{1}", ex.Message, ex.StackTrace));
}
finally
{
if (cb != null)
cb.Dispose();
}
return;
}
override internal void Run(IPresent ip, Row row)
{
base.Run(ip, row);
string mtype=null;
Stream strm=null;
try
{
strm = GetImageStream(ip.Report(), row, out mtype);
ip.Image(this, row, mtype, strm);
}
catch
{
// image failed to load; continue processing
}
finally
{
if (strm != null)
strm.Close();
}
return;
}
internal void Run(IPresent ip)
{
if (_Subreport == null)
{ // do true intialization
ip.Start();
}
if (ip.IsPagingNeeded())
{
RunPage(ip);
}
else
{
if (_PageHeader != null && !(ip is RenderXml))
_PageHeader.Run(ip, null);
_Body.Run(ip, null);
if (_PageFooter != null && !(ip is RenderXml))
_PageFooter.Run(ip, null);
}
if (_Subreport == null)
ip.End();
if (_DataSourcesDefn != null)
_DataSourcesDefn.CleanUp(ip.Report()); // datasets may not have been cleaned up
}
internal virtual void Run(IPresent ip, Row row)
{
return;
}
internal virtual void Run(IPresent ip, Row row)
{
return;
}
internal void Run(IPresent ip, Row row)
{
ip.BodyStart(this);
if (_ReportItems != null)
_ReportItems.Run(ip, null); // not sure about the row here?
ip.BodyEnd(this);
return ;
}
override internal void Run(IPresent ip, Row row)
{
Report rpt = ip.Report();
WorkClass wc = GetValue(rpt);
wc.FullData = wc.Data = GetFilteredData(rpt, row);
if (!AnyRows(ip, wc.Data)) // if no rows return
return; // nothing left to do
int maxColumns;
int maxRows;
MatrixCellEntry[,] matrix = RunBuild(rpt, out maxRows, out maxColumns);
// Now run thru the rows and columns of the matrix passing the information
// on to the rendering engine
int headerRows = _ColumnGroupings.Items.Count; // number of column headers we have
if (!ip.MatrixStart(this, matrix, row, headerRows, maxRows, maxColumns))
return;
for (int iRow = 0; iRow < maxRows; iRow++)
{
ip.MatrixRowStart(this, iRow, row);
for (int iColumn = 0; iColumn < maxColumns; iColumn++)
{
MatrixCellEntry mce = matrix[iRow, iColumn];
if (mce == null)
{
ip.MatrixCellStart(this, null, iRow, iColumn, row, float.MinValue, float.MinValue, 1);
ip.MatrixCellEnd(this, null, iRow, iColumn, row);
}
else
{
wc.Data = mce.Data; // Must set this for evaluation
Row lrow = wc.Data.Data.Count > 0? wc.Data.Data[0]:null;
mce.DisplayItem.SetMC(rpt, mce); // set for use by the display item
SetGroupingValues(rpt, mce);
ip.MatrixCellStart(this, mce.DisplayItem, iRow, iColumn, lrow, mce.Height, mce.Width, mce.ColSpan);
mce.DisplayItem.Run(ip, lrow);
ip.MatrixCellEnd(this, mce.DisplayItem, iRow, iColumn, lrow);
}
}
ip.MatrixRowEnd(this, iRow, row);
}
ip.MatrixEnd(this, row);
RemoveValue(rpt);
}
public void AddPresent(IPresent presentToAdd)
{
this.currentPressnts.Add(presentToAdd);
}
override internal void Run(IPresent ip, Row row)
{
return;
}
private void RunRender(ref IPresent ip, ref Pages pgs)
{
ip.Start();
ip.RunPages(pgs);
ip.End();
}
public Manager()
{
this._data = new Data();
this._presenter = new Presenter();
}
override public void Run(IPresent ip, Row row)
{
ip.Line(this, row);
}
internal void Run(IPresent ip, Row row)
{
}
internal bool AnyRows(IPresent ip, Rows data)
{
if (data == null || data.Data == null ||
data.Data.Count <= 0)
{
string msg;
if (this.NoRows != null)
msg = this.NoRows.EvaluateString(ip.Report(), null);
else
msg = null;
ip.DataRegionNoRows(this, msg);
return false;
}
return true;
}
/// <summary>
/// Renders the report using the requested presentation type.
/// </summary>
/// <param name="sg">IStreamGen for generating result stream</param>
/// <param name="type">Presentation type: HTML, XML, PDF, MHT, or ASP compatible HTML</param>
/// <param name="prefix">For HTML puts prefix allowing unique name generation</param>
public void RunRender(IStreamGen sg, OutputPresentationType type, string prefix)
{
if (sg == null)
{
throw new ArgumentException("IStreamGen argument cannot be null.", "sg");
}
RenderHtml rh = null;
PageNumber = 1; // reset page numbers
TotalPages = 1;
//Replaced from forum, User: Aulofee http://www.fyireporting.com/forum/viewtopic.php?t=793
IPresent ip = null;
try
{
MemoryStreamGen msg = null;
switch (type)
{
case OutputPresentationType.PDF:
ip = new RenderPdf(this, sg);
_Report.Run(ip);
break;
case OutputPresentationType.TIF:
ip = new RenderTif(this, sg);
_Report.Run(ip);
break;
case OutputPresentationType.TIFBW:
RenderTif rtif = new RenderTif(this, sg);
rtif.RenderColor = false;
ip = rtif;
_Report.Run(ip);
break;
case OutputPresentationType.XML:
if (_Report.DataTransform != null && _Report.DataTransform.Length > 0)
{
//TODO: Make uniform, use RenderXML.
msg = new MemoryStreamGen();
ip = new RenderXml(this, msg);
_Report.Run(ip);
RunRenderXmlTransform(sg, msg);
}
else
{
ip = new RenderXml(this, sg);
_Report.Run(ip);
}
break;
case OutputPresentationType.MHTML:
this.RunRenderMht(sg);
break;
case OutputPresentationType.CSV:
ip = new RenderCsv(this, sg);
_Report.Run(ip);
break;
case OutputPresentationType.RTF:
ip = new RenderRtf(this, sg);
_Report.Run(ip);
break;
case OutputPresentationType.Excel:
ip = new RenderExcel(this, sg);
_Report.Run(ip);
break;
case OutputPresentationType.ASPHTML:
case OutputPresentationType.HTML:
default:
ip = rh = new RenderHtml(this, sg);
rh.Asp = (type == OutputPresentationType.ASPHTML);
rh.Prefix = prefix;
_Report.Run(ip);
// Retain the CSS and JavaScript
if (rh != null)
{
_CSS = rh.CSS;
_JavaScript = rh.JavaScript;
}
break;
}
sg.CloseMainStream();
_Cache = new RCache();
}
finally
{
if (ip != null)
{
ip.Dispose();
}
}
return;
}
override internal void Run(IPresent ip, Row row)
{
Report r = ip.Report();
TableWorkClass wc = GetValue(r);
if (_IsGrid)
{
wc.Data = Rows.CreateOneRow(r);
}
else
{
wc.Data = GetFilteredData(r, row);
}
if (!AnyRows(ip, wc.Data)) // if no rows return
{
return; // nothing left to do
}
RunPrep(r, row, wc);
if (!ip.TableStart(this, row))
{
return; // render doesn't want to continue
}
if (_TableColumns != null)
{
_TableColumns.Run(ip, row);
}
// Header
if (_Header != null)
{
ip.TableHeaderStart(_Header, row);
Row frow = wc.Data.Data.Count > 0? wc.Data.Data[0]: null;
_Header.Run(ip, frow);
ip.TableHeaderEnd(_Header, row);
}
// Body
ip.TableBodyStart(this, row);
if (wc.RecursiveGroup != null)
{
RunRecursiveGroups(ip, wc);
}
else
{
RunGroups(ip, wc.Groups, wc);
}
ip.TableBodyEnd(this, row);
// Footer
if (_Footer != null)
{
ip.TableFooterStart(_Footer, row);
Row lrow = wc.Data.Data.Count > 0? wc.Data.Data[wc.Data.Data.Count - 1]: null;
_Footer.Run(ip, lrow);
ip.TableFooterEnd(_Footer, row);
}
ip.TableEnd(this, row);
RemoveValue(r);
}
internal void Run(IPresent ip)
{
if (_Subreport == null)
{ // do true intialization
_RuntimeName = 0; // start names off at zero
ip.Start();
}
if (ip.IsPagingNeeded())
{
RunPage(ip);
}
else
{
if (_PageHeader != null && !(ip is RenderXml))
_PageHeader.Run(ip, null);
_Body.Run(ip, null);
if (_PageFooter != null && !(ip is RenderXml))
_PageFooter.Run(ip, null);
}
if (_Subreport == null)
ip.End();
}
public void Run(IPresent ip, Row row)
{
_TableRows.Run(ip, row);
return;
}
internal void RunPage(IPresent ip)
{
Pages pgs = new Pages(this);
try
{
Page p = new Page(1); // kick it off with a new page
pgs.AddPage(p);
// Create all the pages
_Body.RunPage(pgs);
if (pgs.LastPage.IsEmpty()) // get rid of extraneous pages which
pgs.RemoveLastPage(); // can be caused by region page break at end
// Now create the headers and footers for all the pages (as needed)
if (_PageHeader != null)
_PageHeader.RunPage(pgs);
if (_PageFooter != null)
_PageFooter.RunPage(pgs);
ip.RunPages(pgs);
}
finally
{
pgs.CleanUp(); // always want to make sure we clean this up since
}
return;
}
override public void Run(IPresent ip, Row row)
{
return;
}
internal void Run(IPresent ip, Row row)
{
_TableRows.Run(ip, row);
return;
}
internal void Run(IPresent ip, Rows rs, int start, int end)
{
// if no rows output or rows just leave
if (rs == null || rs.Data == null)
return;
if (this.Visibility != null && Visibility.IsHidden(ip.Report(), rs.Data[start]) && Visibility.ToggleItem == null)
return; // not visible
for (int r=start; r <= end; r++)
{
_TableRows.Run(ip, rs.Data[r]);
}
return;
}
override public void Run(IPresent ip, Row row)
{
base.Run(ip, row);
if (_ReportItems == null)
return;
if (ip.RectangleStart(this, row))
{
_ReportItems.Run(ip, row);
ip.RectangleEnd(this, row);
}
}
internal void Run(IPresent ip, Row row)
{
if (OwnerReport.Subreport != null)
return; // don't process page footers for sub-reports
Report rpt = ip.Report();
rpt.TotalPages = rpt.PageNumber = 1;
ip.PageFooterStart(this);
if (_ReportItems != null)
_ReportItems.Run(ip, row);
ip.PageFooterEnd(this);
}
override internal void Run(IPresent ip, Row row)
{
ip.Line(this, row);
}
internal void RunPage(IPresent ip)
{
Pages pgs = new Pages(ip.Report());
try
{
Page p = new Page(1); // kick it off with a new page
pgs.AddPage(p);
// Create all the pages
_Body.RunPage(pgs);
if (pgs.LastPage.IsEmpty()) // get rid of extraneous pages which
pgs.RemoveLastPage(); // can be caused by region page break at end
// Now create the headers and footers for all the pages (as needed)
if (_PageHeader != null)
_PageHeader.RunPage(pgs);
if (_PageFooter != null)
_PageFooter.RunPage(pgs);
pgs.SortPageItems(); // Handle ZIndex ordering of pages
ip.RunPages(pgs);
}
finally
{
pgs.CleanUp(); // always want to make sure we clean this up since
if (_DataSourcesDefn != null)
_DataSourcesDefn.CleanUp(pgs.Report); // ensure datasets are cleaned up
}
return;
}
override internal void Run(IPresent ip, Row row)
{
Report r = ip.Report();
WorkClass wc = GetValue(r);
wc.Data = GetFilteredData(r, row);
if (!AnyRows(ip, wc.Data)) // if no rows return
return; // nothing left to do
RunSetGrouping(r, wc);
base.Run(ip, row);
if (!ip.ListStart(this, row))
return; // renderer doesn't want to continue
RunGroups(ip, wc, wc.Groups);
ip.ListEnd(this, row);
RemoveValue(r);
}
internal void Run(IPresent ip, Row row)
{
if (this.Visibility != null && Visibility.IsHidden(ip.Report(), row))
return;
ip.TableRowStart(this, row);
_TableCells.Run(ip, row);
ip.TableRowEnd(this, row);
return ;
}
override internal void Run(IPresent ip, Row row)
{
base.Run(ip, row);
}
override internal void Run(IPresent ip, Row row)
{
return;
}
public virtual void Run(IPresent ip, Row row)
{
return;
}
private void RunGroups(IPresent ip, WorkClass wc, List<GroupEntry> groupEntries)
{
foreach (GroupEntry ge in groupEntries)
{
// set the group entry value
int index;
if (ge.Group != null) // groups?
{
ge.Group.ResetHideDuplicates(ip.Report()); // reset duplicate checking
index = ge.Group.GetIndex(ip.Report()); // yes
}
else // no; must be main dataset
index = 0;
wc.Data.CurrentGroups[index] = ge;
if (ge.NestedGroup.Count > 0)
RunGroupsSetGroups(ip.Report(), wc, ge.NestedGroup);
if (ge.Group == null)
{ // need to run all the rows since no group defined
for (int r=ge.StartRow; r <= ge.EndRow; r++)
{
ip.ListEntryBegin(this, wc.Data.Data[r]);
_ReportItems.Run(ip, wc.Data.Data[r]);
ip.ListEntryEnd(this, wc.Data.Data[r]);
}
}
else
{ // need to process just whole group as a List entry
ip.ListEntryBegin(this, wc.Data.Data[ge.StartRow]);
// pass the first row of the group
_ReportItems.Run(ip, wc.Data.Data[ge.StartRow]);
ip.ListEntryEnd(this, wc.Data.Data[ge.StartRow]);
}
}
}
internal void Run(IPresent ip, Row row)
{
}
internal void Run(IPresent ip, Row row)
{
_TableRows.Run(ip, row);
return;
}
override public void Run(IPresent ip, Row row)
{
base.Run(ip, row);
}
override internal void Run(IPresent ip, Row row)
{
base.Run(ip, row);
}
internal void Run(IPresent ip, Row row)
{
// todo: visibility on the column should really only be evaluated once at the beginning
// of the table processing; also this doesn't account for the affect of colspan correctly
// where if any of the spanned columns are visible the value would show??
TableColumn tc = _OwnerTable.TableColumns[_ColIndex];
if (tc.Visibility != null && tc.Visibility.IsHidden(ip.Report(), row)) // column visible?
return; // no nothing to do
ip.TableCellStart(this, row);
_ReportItems.Items[0].Run(ip, row);
ip.TableCellEnd(this, row);
return;
}
override public void Run(IPresent ip, Row row)
{
Report r = ip.Report();
base.Run(ip, row);
// need to save the owner report and nest in this defintion
ReportDefn saveReport = r.ReportDefinition;
NeedPassword np = r.GetDataSourceReferencePassword; // get current password
r.SetReportDefinition(_ReportDefn);
r.Folder = _ReportDefn.ParseFolder; // folder needs to get set since the id of the report is used by the cache
r.GetDataSourceReferencePassword = np;
DataSourcesDefn saveDS = r.ParentConnections;
if (this.MergeTransactions)
r.ParentConnections = saveReport.DataSourcesDefn;
else
r.ParentConnections = null;
r.SubreportDataRetrievalTriggerEvent();
if (_Parameters == null)
{ // When no parameters we only retrieve data once
if (r.Cache.Get(this, "report") == null)
{
r.RunGetData(null);
if (!r.IsSubreportDataRetrievalDefined) // if use has defined subreportdataretrieval they might
r.Cache.Add(this, "report", this); // set the data; so we don't cache
}
}
else
{
SetSubreportParameters(r, row);
r.RunGetData(null);
}
ip.Subreport(this, row);
r.SetReportDefinition(saveReport); // restore the current report
r.ParentConnections = saveDS; // restore the data connnections
}
public void Run(IPresent ip, Row row)
{
_TableRows.Run(ip, row);
return;
}
internal void Run(IPresent ip, Row row)
{
foreach (ReportItem ri in _Items)
{
ri.Run(ip, row);
}
return;
}
override internal void Run(IPresent ip, Row row)
{
ip.Line(this, row);
}
private void RunGroups(IPresent ip, List <GroupEntry> groupEntries, TableWorkClass wc)
{
Report rpt = ip.Report();
GroupEntry fge = (GroupEntry)(groupEntries[0]);
if (fge.Group != null)
{
ip.GroupingStart(fge.Group);
}
foreach (GroupEntry ge in groupEntries)
{
// set the group entry value
int index;
if (ge.Group != null) // groups?
{
ip.GroupingInstanceStart(ge.Group);
ge.Group.ResetHideDuplicates(rpt); // reset duplicate checking
index = ge.Group.GetIndex(rpt); // yes
}
else // no; must be main dataset
{
index = 0;
}
wc.Data.CurrentGroups[index] = ge;
if (ge.NestedGroup.Count > 0)
{
RunGroupsSetGroups(rpt, wc, ge.NestedGroup);
}
// Handle the group header
if (ge.Group != null && ge.Group.Parent != null)
{
TableGroup tg = ge.Group.Parent as TableGroup;
if (tg != null && tg.Header != null)
{
// Calculate the number of table rows below this group; header, footer, details count
if (ge.NestedGroup.Count > 0)
{
wc.GroupNestCount = RunGroupsCount(ge.NestedGroup, 0);
}
else
{
wc.GroupNestCount = (ge.EndRow - ge.StartRow + 1) * DetailsCount;
}
tg.Header.Run(ip, wc.Data.Data[ge.StartRow]);
wc.GroupNestCount = 0;
}
}
// Handle the nested groups if any
if (ge.NestedGroup.Count > 0)
{
RunGroups(ip, ge.NestedGroup, wc);
}
// If no nested groups then handle the detail rows for the group
else if (_Details != null)
{
if (ge.Group != null &&
ge.Group.Parent as TableGroup == null)
{ // Group defined on table; means that Detail rows only put out once per group
_Details.Run(ip, wc.Data, ge.StartRow, ge.StartRow);
}
else
{
_Details.Run(ip, wc.Data, ge.StartRow, ge.EndRow);
}
}
// Do the group footer
if (ge.Group != null)
{
if (ge.Group.Parent != null)
{
TableGroup tg = ge.Group.Parent as TableGroup; // detail groups will result in null
if (tg != null && tg.Footer != null)
{
tg.Footer.Run(ip, wc.Data.Data[ge.EndRow]);
}
}
ip.GroupingInstanceEnd(ge.Group);
}
}
if (fge.Group != null)
{
ip.GroupingEnd(fge.Group);
}
}
override internal void Run(IPresent ip, Row row)
{
Report rpt = ip.Report();
base.Run(ip, row);
TextboxRuntime tbr = TextboxRuntime.GetTextboxRuntime(rpt, this);
tbr.RunCount++; // Increment the run count
string t = RunText(rpt, row);
bool bDup = RunTextIsDuplicate(tbr, t, null);
if (bDup)
{
if (!(this.IsTableOrMatrixCell(rpt))) // don't put out anything if not in Table or Matrix
return;
t = ""; // still need to put out the cell
}
ip.Textbox(this, t, row);
if (!bDup)
tbr.PreviousText=t; // set for next time
}
override internal void Run(IPresent ip, Row row)
{
Report rpt = ip.Report();
ICustomReportItem cri = null;
try
{
cri = RdlEngineConfig.CreateCustomReportItem(_Type);
}
catch (Exception ex)
{
rpt.rl.LogError(8, string.Format("Exception in CustomReportItem handling.\n{0}\n{1}", ex.Message, ex.StackTrace));
}
finally
{
if (cri != null)
cri.Dispose();
}
return;
}
public void Run(IPresent ip, Row row)
{
}
