public void CalculatePageBounds (IReportModel reportModel)
		{
			MeasureReportHeader(reportModel.ReportHeader);
			MeasurePageHeader(reportModel.PageHeader);
			MeasurePageFooter(reportModel.PageFooter);
			MeasureReportFooter(reportModel.ReportFooter);
		}

		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;
		}	

		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 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);

		}

		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 static FormPageBuilder CreateInstance(IReportModel reportModel)
		{
			if (reportModel == null) {
				throw new ArgumentNullException("reportModel");
			}
			FormPageBuilder instance = new FormPageBuilder(reportModel);
			return instance;
		}

		public BasePageBuilder(IReportModel reportModel)
		{
			if (reportModel == null) {
				 throw new ArgumentNullException("reportModel");
			}
			ReportModel = reportModel;
			Pages = new Collection<IPage>();
			graphics = CreateGraphics.FromSize(reportModel.ReportSettings.PageSize);
		}

		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 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 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)
		{
			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 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 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);
		}

		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 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;
		}