protected AbstractRenderer SetupPushDataRenderer(IReportModel model,
DataTable dataTable)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (model.ReportSettings.ReportType != GlobalEnums.ReportType.DataReport)
{
throw new ArgumentException("SetupPushDataRenderer <No valid ReportModel>");
}
if (model.ReportSettings.DataModel != GlobalEnums.PushPullModel.PushData)
{
throw new ArgumentException("SetupPushDataRenderer <No valid ReportType>");
}
AbstractRenderer abstr = null;
IDataManager dataMan = DataManager.CreateInstance(dataTable, model.ReportSettings);
if (dataMan != null)
{
abstr = RendererFactory.Create(model, dataMan);
abstr.Rendering += new EventHandler <SectionRenderEventArgs>(OnSectionPrinting);
abstr.SectionRendered += new EventHandler <SectionRenderEventArgs>(OnSectionPrinted);
return(abstr);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="reportModel"></param>
/// <param name="dataTable"></param>
/// <param name="reportParameters"></param>
/// <returns></returns>
public static IReportCreator CreatePageBuilder(IReportModel reportModel,
DataTable dataTable,
ReportParameters reportParameters)
{
Console.WriteLine("ReportEngine:CreatePageBuilder_3");
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
if (dataTable == null)
{
throw new ArgumentNullException("dataTable");
}
ReportEngine.CheckForParameters(reportModel, reportParameters);
IDataManager dataMan = DataManager.CreateInstance(dataTable, reportModel.ReportSettings);
if (dataMan != null)
{
return(DataPageBuilder.CreateInstance(reportModel, dataMan));
}
else
{
throw new MissingDataManagerException();
}
}
/*
* protected static ColumnCollection CollectFieldsFromModel(ReportModel model){
* if (model == null) {
* throw new ArgumentNullException("model");
* }
* ColumnCollection col = new ColumnCollection();
*
* foreach (BaseSection section in model.SectionCollection){
* for (int i = 0;i < section.Items.Count ;i ++ ) {
* IReportItem item = section.Items[i];
* BaseDataItem baseItem = item as BaseDataItem;
* if (baseItem != null) {
* col.Add(new AbstractColumn(baseItem.ColumnName));
* }
* }
* }
* return col;
* }
*/
/// <summary>
/// Creates an <see cref="AbstractRenderer"></see>
/// any Class deriving from this can be
/// used to get a <see cref="System.Drawing.Printing.PrintDocument"></see>
/// </summary>
/// <param name="model"><see cref="ReportModel"></see></param>
/// <returns></returns>
protected AbstractRenderer SetupStandardRenderer(IReportModel model, ReportParameters parameters)
{
AbstractRenderer abstr = null;
try {
switch (model.ReportSettings.ReportType)
{
//FormSheets reports
case GlobalEnums.ReportType.FormSheet:
abstr = RendererFactory.Create(model, null);
break;
//Databased reports
case GlobalEnums.ReportType.DataReport:
IDataManager dataMan = DataManagerFactory.CreateDataManager(model, parameters);
abstr = RendererFactory.Create(model, dataMan);
break;
default:
throw new ReportException("SharpReportmanager:SetupRenderer -> Unknown Reporttype");
}
abstr.Rendering += new EventHandler <SectionRenderEventArgs>(OnSectionPrinting);
abstr.SectionRendered += new EventHandler <SectionRenderEventArgs>(OnSectionPrinted);
return(abstr);
} catch (Exception) {
throw;
}
}
public void ProcessReport(Stream TemplateFileStream, string destinationFile, IReportModel Data)
{
DestinationFile = destinationFile;
Document = new SLDocument(TemplateFileStream);
SubProcess(Data);
Document.SaveAs(DestinationFile);
}
public IReportCreator ReportCreator(IReportModel reportModel)
{
ReportModel = reportModel;
var builder = new FormPageBuilder(ReportModel);
return(builder);
}
/// <summary>
///
/// </summary>
/// <param name="reportModel"></param>
/// <param name="list"></param>
/// <param name="reportParameters"></param>
/// <returns></returns>
public static IReportCreator CreatePageBuilder(IReportModel reportModel,
IList list,
ReportParameters reportParameters)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
if (list == null)
{
throw new ArgumentNullException("list");
}
ReportEngine.CheckForParameters(reportModel, reportParameters);
IDataManager dataMan = DataManager.CreateInstance(list, reportModel.ReportSettings);
if (dataMan != null)
{
Layouter layouter = new Layouter();
return(DataPageBuilder.CreateInstance(reportModel, dataMan, layouter));
}
else
{
throw new MissingDataManagerException();
}
}
public void CalculatePageBounds(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
sectionBounds.MeasureReportHeader(reportModel.ReportHeader);
//PageHeader
this.sectionBounds.MeasurePageHeader(reportModel.PageHeader);
//PageFooter
this.sectionBounds.MeasurePageFooter(reportModel.PageFooter);
//ReportFooter
this.sectionBounds.MeasureReportFooter(reportModel.ReportFooter);
this.sectionBounds.MeasureDetailArea();
this.sectionBounds.DetailSectionRectangle = new System.Drawing.Rectangle(reportModel.DetailSection.Location.X, sectionBounds.DetailStart.Y,
reportModel.DetailSection.Size.Width,
reportModel.DetailSection.Size.Height);
}
public void CalculatePageBounds(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
sectionBounds.MeasureReportHeader(reportModel.ReportHeader);
//PageHeader
this.sectionBounds.MeasurePageHeader(reportModel.PageHeader);
//PageFooter
this.sectionBounds.MeasurePageFooter(reportModel.PageFooter);
//ReportFooter
this.sectionBounds.MeasureReportFooter(reportModel.ReportFooter);
this.sectionBounds.MeasureDetailArea();
this.sectionBounds.DetailSectionRectangle = new System.Drawing.Rectangle(reportModel.DetailSection.Location.X,sectionBounds.DetailStart.Y,
reportModel.DetailSection.Size.Width,
reportModel.DetailSection.Size.Height);
}
public void CalculatePageBounds(IReportModel reportModel)
{
MeasureReportHeader(reportModel.ReportHeader);
MeasurePageHeader(reportModel.PageHeader);
MeasurePageFooter(reportModel.PageFooter);
MeasureReportFooter(reportModel.ReportFooter);
}
public void LoadModelFromStream()
{
Assembly asm = Assembly.GetExecutingAssembly();
var stream = asm.GetManifestResourceStream(TestHelper.RepWithTwoItems);
var rf = new ReportingFactory();
model = rf.LoadReportModel(stream);
}
public void LoadModelFromStream()
{
System.Reflection.Assembly asm = Assembly.GetExecutingAssembly();
var stream = asm.GetManifestResourceStream(TestHelper.ReportFromList);
var rf = new ReportingFactory();
model = rf.LoadReportModel(stream);
}
public static IDataManager CreateDataManager (IReportModel reportModel,ReportParameters reportParameters)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
IDataManager dataManager = null;
ConnectionObject connectionObject = null;
IDataAccessStrategy accesStrategy = null;
if (reportParameters != null) {
connectionObject = reportParameters.ConnectionObject;
}
// if (connectionObject != null) {
// accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings,connectionObject);
// } else {
// accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings,null);
//
// }
accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings);
dataManager = DataManager.CreateInstance(reportModel.ReportSettings,accesStrategy);
if (dataManager == null) {
throw new MissingDataManagerException();
}
return dataManager;
}
private static void ReportToPrinter(AbstractRenderer renderer, IReportModel model)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
PrintDocument doc = null;
if (renderer.Cancel == false)
{
doc = renderer.ReportDocument;
using (PrintDialog dlg = new PrintDialog()) {
dlg.Document = doc;
if (model.ReportSettings.UseStandardPrinter == true)
{
dlg.Document.Print();
}
else
{
DialogResult result = dlg.ShowDialog();
// If the result is OK then print the document.
if (result == DialogResult.OK)
{
dlg.Document.Print();
}
}
}
}
}
public void CalculatePageBounds (IReportModel reportModel)
{
MeasureReportHeader(reportModel.ReportHeader);
MeasurePageHeader(reportModel.PageHeader);
MeasurePageFooter(reportModel.PageFooter);
MeasureReportFooter(reportModel.ReportFooter);
}
public void PreviewPushDataReport(string fileName, IList list, ReportParameters reportParameters)
{
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (list == null)
{
throw new ArgumentNullException("list");
}
AbstractRenderer renderer = null;
try {
IReportModel model = ValidatePushModel(fileName);
CheckForParameters(model, reportParameters);
renderer = this.SetupPushDataRenderer(model, list);
if (renderer != null)
{
PreviewControl.ShowPreview(renderer, 1.5, false);
}
} catch (Exception) {
throw;
}
}
static StringWriter ToXmlInternal(IReportModel model)
{
var writer = new StringWriterWithEncoding(System.Text.Encoding.UTF8);
var xml = XmlHelper.CreatePropperWriter(writer);
var reportDesignerWriter = new ReportDesignerWriter();
XmlHelper.CreatePropperDocument(xml);
reportDesignerWriter.Save(model.ReportSettings,xml);
xml.WriteEndElement();
xml.WriteStartElement("SectionCollection");
// we look only for Sections
foreach (var section in model.SectionCollection) {
reportDesignerWriter.Save(section,xml);
}
//SectionCollection
xml.WriteEndElement();
//Reportmodel
xml.WriteEndElement();
xml.WriteEndDocument();
xml.Close();
return writer;
}
static StringWriter ToXmlInternal(IReportModel model)
{
var writer = new StringWriterWithEncoding(System.Text.Encoding.UTF8);
var xml = XmlHelper.CreatePropperWriter(writer);
var reportDesignerWriter = new ReportDesignerWriter();
XmlHelper.CreatePropperDocument(xml);
reportDesignerWriter.Save(model.ReportSettings, xml);
xml.WriteEndElement();
xml.WriteStartElement("SectionCollection");
// we look only for Sections
foreach (var section in model.SectionCollection)
{
reportDesignerWriter.Save(section, xml);
}
//SectionCollection
xml.WriteEndElement();
//Reportmodel
xml.WriteEndElement();
xml.WriteEndDocument();
xml.Close();
return(writer);
}
public void PreviewPushDataReport(string fileName, DataTable dataTable, ReportParameters reportParameters)
{
Console.WriteLine("ReportEngine:PreviewPushDataReport_1");
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (dataTable == null)
{
throw new ArgumentNullException("dataTable");
}
AbstractRenderer renderer = null;
try {
IReportModel model = ValidatePushModel(fileName);
CheckForParameters(model, reportParameters);
renderer = this.SetupPushDataRenderer(model, dataTable);
if (renderer != null)
{
PreviewControl.ShowPreview(renderer, 1.5, false);
}
} catch (Exception) {
throw;
}
}
public static IDataManager CreateDataManager(IReportModel reportModel, ReportParameters reportParameters)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
IDataManager dataManager = null;
ConnectionObject connectionObject = null;
IDataAccessStrategy accesStrategy = null;
if (reportParameters != null)
{
connectionObject = reportParameters.ConnectionObject;
}
if (connectionObject != null)
{
accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings, connectionObject);
}
else
{
accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings, null);
}
dataManager = DataManager.CreateInstance(reportModel.ReportSettings, accesStrategy);
if (dataManager == null)
{
throw new MissingDataManagerException();
}
return(dataManager);
}
public static FormPageBuilder CreateInstance(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
FormPageBuilder instance = new FormPageBuilder(reportModel);
return instance;
}
public void LoadModelFromStream()
{
System.Reflection.Assembly asm = Assembly.GetExecutingAssembly();
var stream = asm.GetManifestResourceStream(TestHelper.ReportFromList);
var rf = new ReportingFactory();
model = rf.LoadReportModel(stream);
}
public void LoadModelFromStream()
{
Assembly asm = Assembly.GetExecutingAssembly();
var stream = asm.GetManifestResourceStream(TestHelper.RepWithTwoItems);
var rf = new ReportingFactory();
model = rf.LoadReportModel(stream);
}
public BasePageBuilder(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
ReportModel = reportModel;
Pages = new Collection<IPage>();
graphics = CreateGraphics.FromSize(reportModel.ReportSettings.PageSize);
}
private static void SetSqlParam(IReportModel model, SqlParameter param)
{
var p = model.ReportSettings.SqlParameters.Find(param.ParameterName);
if (p != null)
{
p.ParameterValue = param.ParameterValue;
}
}
private static void SetReportParam(IReportModel model, BasicParameter param)
{
var p = model.ReportSettings.ParameterCollection.Find(param.ParameterName);
if (p != null)
{
p.ParameterValue = param.ParameterValue;
}
}
private static void SetSqlParam(IReportModel model, SqlParameter param)
{
Console.WriteLine("ReportEngine:SetSqlparameters");
var p = model.ReportSettings.SqlParameters.Find(param.ParameterName);
if (p != null)
{
p.ParameterValue = param.ParameterValue;
}
}
public static FormPageBuilder CreateInstance(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
FormPageBuilder instance = new FormPageBuilder(reportModel);
return(instance);
}
private static IReportModel ValidatePushModel(string fileName)
{
IReportModel model = LoadReportModel(fileName);
if (model.ReportSettings.DataModel != GlobalEnums.PushPullModel.PushData)
{
throw new InvalidReportModelException();
}
return(model);
}
ISinglePage CreateSinglePage(IReportModel model, int pageNumber)
{
Size defaultSectionSize = new Size(727, 60);
var s = new SectionBounds(model.ReportSettings, true);
SinglePage sp = new SinglePage(s, 0);
sp.CalculatePageBounds(model);
return(sp);
}
private static void SetReportParam(IReportModel model, BasicParameter param)
{
Console.WriteLine("ReportEngine:SetReportParameters");
var p = model.ReportSettings.ParameterCollection.Find(param.ParameterName);
if (p != null)
{
p.ParameterValue = param.ParameterValue;
}
}
public BasePageBuilder(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
ReportModel = reportModel;
Pages = new Collection <ExportPage>();
Graphics = CreateGraphics.FromSize(reportModel.ReportSettings.PageSize);
}
public AbstractDataRenderer(IReportModel model,
IDataManager dataManager,
ReportDocument reportDocument,
ILayouter layout):base(model,reportDocument,layout)
{
if (dataManager == null) {
throw new ArgumentNullException("dataManager");
}
this.dataManager = dataManager;
}
public static IReportCreator CreateInstance(IReportModel reportModel, IDataManager dataManager)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
if (dataManager == null) {
throw new ArgumentNullException("dataManager");
}
DataPageBuilder instance = new DataPageBuilder(reportModel,dataManager);
return instance;
}
public void CalculatePageBounds(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
sectionBounds.CalculatePageBounds(reportModel);
this.sectionBounds.DetailSectionRectangle = new System.Drawing.Rectangle(reportModel.DetailSection.Location.X,sectionBounds.DetailArea.Top,
reportModel.DetailSection.Size.Width,
reportModel.DetailSection.Size.Height);
}
/// <summary>
/// For internal use only
/// </summary>
/// <param name="reportModel"></param>
/// <returns></returns>
public static IReportCreator CreatePageBuilder(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
IDataManager dataMan = DataManagerFactory.CreateDataManager(reportModel, (ReportParameters)null);
IReportCreator builder = DataPageBuilder.CreateInstance(reportModel, dataMan);
return(builder);
}
public BasePager(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
this.ReportModel = reportModel;
//this.Layouter = layouter;
this.Layouter = new Layouter();
this.Graphics = CreateGraphicObject.FromSize(this.ReportModel.ReportSettings.PageSize);
}
public void Calculate_PageHeader()
{
IReportModel model = ReportModel.Create();
ISinglePage singlePage = CreateSinglePage(model, 0);
singlePage.CalculatePageBounds(model);
Point expectedLocation = new Point(model.ReportSettings.LeftMargin, model.ReportSettings.TopMargin + singlePage.SectionBounds.ReportHeaderRectangle.Size.Height + 1);
Assert.That(singlePage.SectionBounds.PageHeaderRectangle.Location, Is.EqualTo(expectedLocation));
}
public void CalculatePageBounds(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
sectionBounds.CalculatePageBounds(reportModel);
this.sectionBounds.DetailSectionRectangle = new System.Drawing.Rectangle(reportModel.DetailSection.Location.X, sectionBounds.DetailArea.Top,
reportModel.DetailSection.Size.Width,
reportModel.DetailSection.Size.Height);
}
public BasePager(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
this.ReportModel = reportModel;
//this.Layouter = layouter;
this.Layouter = new Layouter();
this.Graphics = CreateGraphicObject.FromSize(this.ReportModel.ReportSettings.PageSize);
}
public AbstractDataRenderer(IReportModel model,
IDataManager dataManager,
ReportDocument reportDocument,
ILayouter layout) : base(model, reportDocument, layout)
{
if (dataManager == null)
{
throw new ArgumentNullException("dataManager");
}
this.dataManager = dataManager;
}
public BasePager(IReportModel reportModel,ILayouter layouter)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
if (layouter == null) {
throw new ArgumentNullException ("layouter");
}
this.reportModel = reportModel;
this.layouter = layouter;
this.graphics = CreateGraphicObject.FromSize(this.reportModel.ReportSettings.PageSize);
}
public static IReportCreator CreateInstance(IReportModel reportModel, IDataManager dataManager)
// public static IReportCreator CreateInstance(IReportModel reportModel, IDataManager dataManager,ILayouter layouter)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
if (dataManager == null) {
throw new ArgumentNullException("dataManager");
}
DataPageBuilder instance = new DataPageBuilder(reportModel,dataManager);
return instance;
}
public static IDataManager CreateDataManager (IReportModel reportModel,IList dataTable)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
if (dataTable == null) {
throw new ArgumentNullException("dataTable");
}
IDataManager dataManager = DataManager.CreateInstance(dataTable,reportModel.ReportSettings);
if (dataManager == null) {
throw new MissingDataManagerException();
}
return dataManager;
}
public static StringWriter ToXml(IReportModel reportModel)
{
int locY = reportModel.ReportSettings.TopMargin;
foreach (var section in reportModel.SectionCollection)
{
section.Location = new Point(reportModel.ReportSettings.LeftMargin,locY);
section.Size = new Size(reportModel.ReportSettings.PrintableWidth(),GlobalValues.DefaultSectionHeight + 10);
locY = locY + section.Size.Height + DesignerGlobals.GabBetweenSection;
}
var xml = ToXmlInternal(reportModel);
return xml;
}
public BasePager(IReportModel reportModel)
{
if (reportModel == null) {
throw new ArgumentNullException("reportModel");
}
this.ReportModel = reportModel;
if (!ServiceContainer.Contains(typeof(ILayouter))) {
ServiceContainer.AddService<ILayouter>(new Layouter());
}
this.Graphics = CreateGraphicObject.FromSize(this.ReportModel.ReportSettings.PageSize);
}
/// <summary>
/// For internal use only
/// </summary>
/// <param name="reportModel"></param>
/// <returns></returns>
/*
* internal static IReportCreator CreatePageBuilder (IReportModel reportModel)
* {
* if (reportModel == null) {
* throw new ArgumentNullException("reportModel");
* }
* IDataManager dataMan = DataManagerFactory.CreateDataManager(reportModel,(ReportParameters)null);
* IReportCreator builder = DataPageBuilder.CreateInstance(reportModel, dataMan);
* return builder;
* }
*/
/// <summary>
///
/// </summary>
/// <param name="reportModel"></param>
/// <param name="dataSet"></param>
/// <param name="reportParameter"></param>
/// <returns></returns>
public static IReportCreator CreatePageBuilder(IReportModel reportModel,
DataSet dataSet,
ReportParameters reportParameter)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
if (dataSet == null)
{
throw new ArgumentNullException("dataSet");
}
return(CreatePageBuilder(reportModel, dataSet.Tables[0], reportParameter));
}
public BaseConverter(IReportModel reportModel,IDataNavigator dataNavigator,ExporterPage singlePage)
{
if (dataNavigator == null) {
throw new ArgumentNullException("dataNavigator");
}
if (singlePage == null) {
throw new ArgumentNullException("singlePage");
}
this.ReportModel = reportModel;
this.SinglePage = singlePage;
this.DataNavigator = dataNavigator;
this.Layouter = (ILayouter)ServiceContainer.GetService(typeof(ILayouter));
this.Evaluator = EvaluationHelper.CreateEvaluator(this.SinglePage,this.DataNavigator);
}
public static AbstractRenderer Create(IReportModel model,IDataManager container) {
ReportDocument repDocumet = new ReportDocument();
if (model != null) {
Layouter layouter = new Layouter();
switch (model.ReportSettings.ReportType) {
case GlobalEnums.ReportType.FormSheet :{
return new RenderFormSheetReport(model,repDocumet,layouter);
}
case GlobalEnums.ReportType.DataReport:{
return new RenderDataReport(model,container,repDocumet,layouter);
}
}
}
throw new MissingModelException();
}
public static IBaseConverter CreateConverter (BaseReportItem itemToConvert,IReportModel reportModel,
IDataNavigator dataNavigator,ExporterPage singlePage)
{
Type t = itemToConvert.GetType();
if (t.Equals(typeof(BaseTableItem))) {
return new GroupedTableConverter(reportModel,dataNavigator,singlePage);
}
if (t.Equals(typeof(BaseRowItem))) {
return new GroupedRowConverter (reportModel,dataNavigator,singlePage);
}
return null;
}
public StringWriter ToXml(IReportModel reportModel) {
int locY = reportModel.ReportSettings.TopMargin;
foreach (var section in reportModel.SectionCollection)
{
section.Location = new Point(reportModel.ReportSettings.LeftMargin,locY);
section.Size = new Size(reportModel.ReportSettings.PageSize.Width - reportModel.ReportSettings.LeftMargin - reportModel.ReportSettings.RightMargin,
70);
locY = locY + section.Size.Height + DesignerGlobals.GabBetweenSection;
}
var xml = ToXmlInternal(reportModel);
return xml;
}
public IReportCreator ReportCreator(string fileName,IEnumerable list)
{
if (String.IsNullOrEmpty(fileName)) {
throw new ArgumentNullException("fileName");
}
var doc = new XmlDocument();
try {
doc.Load(fileName);
} catch (Exception e) {
throw e;
}
ReportModel = LoadModel(doc);
var builder = new DataPageBuilder(ReportModel,list);
return builder;
}
protected AbstractRenderer(IReportModel reportModel,ReportDocument reportDocument,ILayouter layout)
{
if (reportModel == null) {
throw new MissingModelException();
}
if (reportDocument == null) {
throw new ArgumentNullException("reportDocument");
}
if (layout == null) {
throw new ArgumentNullException("layout");
}
this.reportModel = reportModel;
this.reportSettings = reportModel.ReportSettings;
this.reportDocument = reportDocument;
this.layout = layout;
this.sections = reportModel.SectionCollection;
Init();
}
public static IReportCreator ExporterFactory(IReportModel reportModel)
{
IReportCreator reportCreator = null;
switch (reportModel.ReportSettings.DataModel) {
case GlobalEnums.PushPullModel.FormSheet:
{
reportCreator = new FormPageBuilder(reportModel);
break;
}
case GlobalEnums.PushPullModel.PullData:
{
break;
}
case GlobalEnums.PushPullModel.PushData:
{
break;
}
}
return reportCreator;
}
public RenderFormSheetReport (IReportModel model,
ReportDocument reportDcoument,
ILayouter layout):base( model,reportDcoument,layout)
{
}
ISinglePage CreateSinglePage(IReportModel model,int pageNumber)
{
Size defaultSectionSize = new Size (727,60);
var s = new SectionBounds(model.ReportSettings,true);
SinglePage sp = new SinglePage(s,0);
sp.CalculatePageBounds(model);
return sp;
}
private DataPageBuilder (IReportModel reportModel,IDataManager dataManager,ILayouter layouter):base(reportModel,layouter)
{
this.dataManager = dataManager;
}
public FormPageBuilder(IReportModel reportModel):base(reportModel)
{
}
public GroupedRowConverter(IReportModel reportModel,IDataNavigator dataNavigator,
ExporterPage singlePage):base(reportModel,dataNavigator,singlePage)
{
}
public RenderDataReport(IReportModel model,
IDataManager dataManager,
ReportDocument reportDocument,
ILayouter layout):base (model,dataManager,reportDocument,layout)
{
}
private FormPageBuilder(IReportModel reportModel):base(reportModel)
{
}
